WriteOptions (json-io 4.19.0 API)

java.lang.Object
- com.cedarsoftware.util.io.WriteOptions

```
public class WriteOptions
extends Object
```
This class contains all the "feature" control (options) for controlling json-io's output JSON. An instance of this class is passed to the JsonWriter.toJson() APIs to establish the desired capabilities.

You can "seal" this class from immutability and then store the class for re-use. Call the "seal" method and then no longer can any methods that change state be called - they will throw a JsonIoException if called after sealing.

This class can be created from another WriteOptions instance, using the "copy constructor" that takes a WriteOptions. All properties of the other WriteOptions will be copied to the new instance, except for the sealed property. That always starts off as false (not sealed) so that you can make changes to options. You can create a few variations of the WriteOptions, store them off, so that you do not have to re-create them frequently.

Author:

John DeRegnaucourt ([email protected]), Kenny Partlow ([email protected])
Copyright (c) Cedar Software LLC

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

License

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class WriteOptions.ShowType

Nested Classes
Modifier and Type	Class and Description
`static class`	`WriteOptions.ShowType`

Field Summary

Fields
Modifier and Type Field and Description

static String ISO_DATE_FORMAT

static String ISO_DATE_TIME_FORMAT

Fields
Modifier and Type	Field and Description
`static String`	`ISO_DATE_FORMAT`
`static String`	`ISO_DATE_TIME_FORMAT`

Constructor Summary

Constructors
Constructor and Description

WriteOptions()
Start with default options

WriteOptions(WriteOptions other)
Copy all the settings from the passed in 'other' WriteOptions

Constructors
Constructor and Description
`WriteOptions()` Start with default options
`WriteOptions(WriteOptions other)` Copy all the settings from the passed in 'other' WriteOptions

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`WriteOptions`	`addCustomWrittenClass(Class<?> clazz, JsonWriter.JsonClassWriter customWriter)`
`WriteOptions`	`addExcludedField(Class<?> clazz, String excludedField)`
`WriteOptions`	`addExcludedFields(Class<?> clazz, Collection<String> excludedFields)`
`WriteOptions`	`addExcludedFields(Map<Class<?>,Collection<String>> excludedFields)`
`WriteOptions`	`addIncludedField(Class<?> clazz, String includedField)`
`WriteOptions`	`addIncludedFields(Class<?> clazz, Collection<String> includedFields)`
`WriteOptions`	`addIncludedFields(Map<Class<?>,Collection<String>> includedFields)`
`WriteOptions`	`addNonReferenceableClass(Class<?> clazz)`
`WriteOptions`	`addNotCustomWrittenClass(Class<?> notCustomClass)` Add a class to the not-customized list - the list of classes that you do not want to be picked up by a custom writer (that could happen through inheritance).
`WriteOptions`	`aliasTypeName(String typeName, String alias)`
`Map<String,String>`	`aliasTypeNames()`
`WriteOptions`	`aliasTypeNames(Map<String,String> aliasTypeNames)`
`WriteOptions`	`allowNanAndInfinity(boolean allowNanAndInfinity)`
`WriteOptions`	`build()` Seal the instance of this class so that no more changes can be made to it.
`WriteOptions`	`classLoader(ClassLoader classLoader)`
`WriteOptions`	`dateTimeFormat(String format)` Change the date-time format to the passed in format.
`WriteOptions`	`forceMapOutputAsTwoArrays(boolean forceMapOutputAsTwoArrays)`
`ClassLoader`	`getClassLoader()`
`JsonWriter.JsonClassWriter`	`getCustomWriter(Class<?> c)` Fetch the custom writer for the passed in Class.
`Map<Class<?>,JsonWriter.JsonClassWriter>`	`getCustomWrittenClasses()`
`Set<Accessor>`	`getExcludedAccessors(Class<?> clazz)` Get the list of Accessors associated to the passed in class that are to be excluded in the written JSON.
`Collection<Accessor>`	`getExcludedAccessorsForClass(Class<?> c)`
`Set<String>`	`getExcludedFields(Class<?> clazz)` Get the list of fields associated to the passed in class that are to be excluded in the written JSON.
`Map<Class<?>,Set<String>>`	`getExcludedFieldsPerAllClasses()`
`Set<Accessor>`	`getIncludedAccessors(Class<?> clazz)` Get the list of Accessors associated to the passed in class that are to be included in the written JSON.
`Collection<Accessor>`	`getIncludedAccessorsForClass(Class<?> c)`
`Map<Class<?>,Set<Accessor>>`	`getIncludedAccessorsPerAllClasses()`
`Set<String>`	`getIncludedFields(Class<?> clazz)` Get the list of fields associated to the passed in class that are to be included in the written JSON.
`Map<Class<?>,Set<String>>`	`getIncludedFieldsPerAllClasses()`
`Collection<Class<?>>`	`getNonReferenceableClasses()`
`Set<Class<?>>`	`getNotCustomWrittenClasses()`
`String`	`getTypeNameAlias(String typeName)` Alias Type Names, e.g.
`boolean`	`isAllowNanAndInfinity()`
`boolean`	`isAlwaysShowingType()`
`boolean`	`isBuilt()`
`boolean`	`isCustomWrittenClass(Class<?> clazz)`
`boolean`	`isEnumPublicFieldsOnly()` true indicates that only public fields will be output on an Enum.
`boolean`	`isForceMapOutputAsTwoArrays()`
`boolean`	`isLongDateFormat()`
`boolean`	`isMinimalShowingType()`
`boolean`	`isNeverShowingType()`
`boolean`	`isNonReferenceableClass(Class<?> clazz)`
`boolean`	`isNotCustomWrittenClass(Class<?> clazz)`
`WriteOptions`	`isoDateFormat()` Change the date-time format to the ISO date format: "yyyy-MM-dd".
`WriteOptions`	`isoDateTimeFormat()` Change the date-time format to the ISO date-time format: "yyyy-MM-dd'T'HH:mm:ss" (default).
`boolean`	`isPrettyPrint()`
`boolean`	`isShortMetaKeys()`
`boolean`	`isSkipNullFields()`
`boolean`	`isWriteEnumAsString()`
`boolean`	`isWriteLongsAsStrings()`
`WriteOptions`	`longDateFormat()` Change the java.uti.Date and java.sql.Date format output to a "long," the number of seconds since Jan 1, 1970 at midnight.
`WriteOptions`	`prettyPrint(boolean prettyPrint)`
`WriteOptions`	`setCustomWrittenClasses(Map<Class<?>,JsonWriter.JsonClassWriter> customWrittenClasses)`
`WriteOptions`	`setNotCustomWrittenClasses(Collection<Class<?>> notCustomClasses)`
`WriteOptions`	`shortMetaKeys(boolean shortMetaKeys)`
`WriteOptions`	`showTypeInfoAlways()` Set to always show type
`WriteOptions`	`showTypeInfoMinimal()` Set to show minimal type.
`WriteOptions`	`showTypeInfoNever()` Set to never show type
`WriteOptions`	`skipNullFields(boolean skipNullFields)`
`WriteOptions`	`writeEnumAsJsonObject(boolean writePublicFieldsOnly)` Option to write out all the member fields of an enum.
`WriteOptions`	`writeEnumsAsString()` Option to write out enums as a String, it will write out the enum.name() field.
`WriteOptions`	`writeLongsAsStrings(boolean writeLongsAsStrings)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - ISO_DATE_FORMAT
```
public static final String ISO_DATE_FORMAT
```
    See Also:
    
    Constant Field Values
  - ISO_DATE_TIME_FORMAT
```
public static final String ISO_DATE_TIME_FORMAT
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - WriteOptions
```
public WriteOptions()
```
    Start with default options
  - WriteOptions
```
public WriteOptions(WriteOptions other)
```
    Copy all the settings from the passed in 'other' WriteOptions
    
    Parameters:
    
    other - WriteOptions - source to copy from.
- Method Detail
  - getClassLoader
```
public ClassLoader getClassLoader()
```
    Returns:
    
    ClassLoader to be used when writing JSON to resolve String named classes.
  - classLoader
```
public WriteOptions classLoader(ClassLoader classLoader)
```
    Parameters:
    
    classLoader - ClassLoader to use when writing JSON to resolve String named classes.
    
    Returns:
    
    WriteOptions for chained access.
  - isShortMetaKeys
```
public boolean isShortMetaKeys()
```
    Returns:
    
    boolean true if showing short meta-keys (@i instead of @id, @ instead of @ref, @t instead of @type, @k instead of @keys, @v instead of @values), false for full size. 'false' is the default.
  - shortMetaKeys
```
public WriteOptions shortMetaKeys(boolean shortMetaKeys)
```
    Parameters:
    
    shortMetaKeys - boolean true to turn on short meta-keys, false for long.
    
    Returns:
    
    WriteOptions for chained access.
  - getTypeNameAlias
```
public String getTypeNameAlias(String typeName)
```
    Alias Type Names, e.g. "alist" instead of "java.util.ArrayList".
    
    Parameters:
    
    typeName - String name of type to fetch alias for. There are no default aliases.
    
    Returns:
    
    String alias name or null if type name is not aliased.
  - aliasTypeNames
```
public Map<String,String> aliasTypeNames()
```
    Returns:
    
    Map containing String class names to alias names.
  - aliasTypeNames
```
public WriteOptions aliasTypeNames(Map<String,String> aliasTypeNames)
```
    Parameters:
    
    aliasTypeNames - Map containing String class names to alias names. The passed in Map will be copied, and be the new baseline settings.
    
    Returns:
    
    WriteOptions for chained access.
  - aliasTypeName
```
public WriteOptions aliasTypeName(String typeName,
                                  String alias)
```
    Parameters:
    
    typeName - String class name
    
    alias - String shorter name to use, typically.
    
    Returns:
    
    WriteOptions for chained access.
  - isAlwaysShowingType
```
public boolean isAlwaysShowingType()
```
    Returns:
    
    boolean true if set to always show type (@type)
  - isNeverShowingType
```
public boolean isNeverShowingType()
```
    Returns:
    
    boolean true if set to never show type (no @type)
  - isMinimalShowingType
```
public boolean isMinimalShowingType()
```
    Returns:
    
    boolean true if set to show minimal type (@type)
  - showTypeInfoAlways
```
public WriteOptions showTypeInfoAlways()
```
    Set to always show type
    
    Returns:
    
    WriteOptions for chained access.
  - showTypeInfoNever
```
public WriteOptions showTypeInfoNever()
```
    Set to never show type
    
    Returns:
    
    WriteOptions for chained access.
  - showTypeInfoMinimal
```
public WriteOptions showTypeInfoMinimal()
```
    Set to show minimal type. This means that when the type of an object can be inferred, a type field will not be output. A Field that points to an instance of the same time, or a typed [] of objects don't need the type info. However, an Object[], a Collection with no generics, the reader will need to know what type the JSON object is, in order to instantiate the write Java class to which the information will be copied.
    
    Returns:
    
    WriteOptions for chained access.
  - isPrettyPrint
```
public boolean isPrettyPrint()
```
    Returns:
    
    boolean 'prettyPrint' setting, true being yes, pretty-print mode using lots of vertical white-space and indentations, 'false' will output JSON in one line. The default is false.
  - prettyPrint
```
public WriteOptions prettyPrint(boolean prettyPrint)
```
    Parameters:
    
    prettyPrint - boolean 'prettyPrint' setting, true to turn on, false will turn off.
    
    Returns:
    
    WriteOptions for chained access.
  - isWriteLongsAsStrings
```
public boolean isWriteLongsAsStrings()
```
    Returns:
    
    boolean 'writeLongsAsStrings' setting, true indicating longs will be written as Strings, false to write them out as native JSON longs. Writing Strings as Longs to the JSON, will fix errors in Javascript when an 18-19 digit long value is sent to Javascript. This is because Javascript stores them in Doubles, which cannot handle the precision of an 18-19 digit long, but a String will retain the full value into Javascript. The default is false.
  - writeLongsAsStrings
```
public WriteOptions writeLongsAsStrings(boolean writeLongsAsStrings)
```
    Parameters:
    
    writeLongsAsStrings - boolean true to turn on writing longs as Strings, false to write them as native JSON longs.
    
    Returns:
    
    WriteOptions for chained access.
  - isSkipNullFields
```
public boolean isSkipNullFields()
```
    Returns:
    
    boolean skipNullFields setting, true indicates fields with null values will not be written, false will still output the field with an associated null value. false is the default.
  - skipNullFields
```
public WriteOptions skipNullFields(boolean skipNullFields)
```
    Parameters:
    
    skipNullFields - boolean setting, where true indicates fields with null values will not be written to the JSON, false will allow the field to still be written.
    
    Returns:
    
    WriteOptions for chained access.
  - isForceMapOutputAsTwoArrays
```
public boolean isForceMapOutputAsTwoArrays()
```
    Returns:
    
    boolean 'forceMapOutputAsTwoArrays' setting. true indicates that two arrays will be written to represent a Java Map, one for keys, one for values. false indicates one Java object will be used, if all the keys of the Map are Strings. If not, then the Map will be written out with a key array, and a parallel value array. (@keys:[...], @values:[...]). false is the default.
  - forceMapOutputAsTwoArrays
```
public WriteOptions forceMapOutputAsTwoArrays(boolean forceMapOutputAsTwoArrays)
```
    Parameters:
    
    forceMapOutputAsTwoArrays - boolean 'forceMapOutputAsTwoArrays' setting. true will force Java Maps to be written out as two parallel arrays, once for keys, one array for values. false will write out one JSON { } object, if all keys are Strings. If not, then the Map will be output as two parallel arrays (@keys:[...], @values:[...]).
    
    Returns:
    
    WriteOptions for chained access.
  - isAllowNanAndInfinity
```
public boolean isAllowNanAndInfinity()
```
    Returns:
    
    boolean will return true if NAN and Infinity are allowed to be written out for Doubles and Floats, else null will be written out..
  - allowNanAndInfinity
```
public WriteOptions allowNanAndInfinity(boolean allowNanAndInfinity)
```
    Parameters:
    
    allowNanAndInfinity - boolean 'allowNanAndInfinity' setting. true will allow Double and Floats to be output as NAN and INFINITY, false and these values will come across as null.
    
    Returns:
    
    WriteOptions for chained access.
  - isWriteEnumAsString
```
public boolean isWriteEnumAsString()
```
    Returns:
    
    boolean true if enums are to be written out as Strings (not a full JSON object) when possible.
  - isEnumPublicFieldsOnly
```
public boolean isEnumPublicFieldsOnly()
```
    true indicates that only public fields will be output on an Enum. Enums don't often have fields added to them but if so, then only the public fields will be written. The Enum will be written out in JSON object { } format. If there are not added fields to an Enum, it will be written out as a single line value. The default value is true. If you set this to false, it will change the 'enumFieldsAsObject' to true - because you will be showing potentially more than one value, it will require the enum to be written as an object.
  - writeEnumsAsString
```
public WriteOptions writeEnumsAsString()
```
    Option to write out enums as a String, it will write out the enum.name() field. This is the default way enums will be written out.
    
    Returns:
    
    WriteOptions for chained access.
  - writeEnumAsJsonObject
```
public WriteOptions writeEnumAsJsonObject(boolean writePublicFieldsOnly)
```
    Option to write out all the member fields of an enum. You can also filter the field to write out only the public fields on the enum.
    
    Parameters:
    
    writePublicFieldsOnly - boolean, only write out the public fields when writing enums as objects
    
    Returns:
    
    WriteOptions for chained access.
  - setCustomWrittenClasses
```
public WriteOptions setCustomWrittenClasses(Map<Class<?>,JsonWriter.JsonClassWriter> customWrittenClasses)
```
    Parameters:
    
    customWrittenClasses - Map of Class to JsonWriter.JsonClassWriter. Establish the passed in Map as the established Map of custom writers to be used when writing JSON. Using this method more than once, will set the custom writers to only the values from the Set in the last call made.
    
    Returns:
    
    WriteOptions for chained access.
  - addCustomWrittenClass
```
public WriteOptions addCustomWrittenClass(Class<?> clazz,
                                          JsonWriter.JsonClassWriter customWriter)
```
    Parameters:
    
    clazz - Class to add a custom writer for.
    
    customWriter - JsonClassWriter to use when the passed in Class is encountered during serialization.
    
    Returns:
    
    WriteOptions for chained access.
  - getCustomWrittenClasses
```
public Map<Class<?>,JsonWriter.JsonClassWriter> getCustomWrittenClasses()
```
    Returns:
    
    Map of Class to custom JsonClassWriter's use to write JSON when the class is encountered during serialization to JSON.
  - isCustomWrittenClass
```
public boolean isCustomWrittenClass(Class<?> clazz)
```
    Parameters:
    
    clazz - Class to check to see if there is a custom writer associated to it.
    
    Returns:
    
    boolean true if there is an associated custom writer class associated to the passed in class, false otherwise.
  - isNotCustomWrittenClass
```
public boolean isNotCustomWrittenClass(Class<?> clazz)
```
    Parameters:
    
    clazz - Class to see if it is on the not-customized list. Classes are added to this list when a class is being picked up through inheritance, and you don't want it to have a custom writer associated to it.
    
    Returns:
    
    boolean true if the passed in class is on the not-customized list, false otherwise.
  - getNotCustomWrittenClasses
```
public Set<Class<?>> getNotCustomWrittenClasses()
```
    Returns:
    
    Set of all Classes on the not-customized list.
  - addNotCustomWrittenClass
```
public WriteOptions addNotCustomWrittenClass(Class<?> notCustomClass)
```
    Add a class to the not-customized list - the list of classes that you do not want to be picked up by a custom writer (that could happen through inheritance).
    
    Parameters:
    
    notCustomClass - Class to add to the not-customized list.
    
    Returns:
    
    WriteOptions for chained access.
  - setNotCustomWrittenClasses
```
public WriteOptions setNotCustomWrittenClasses(Collection<Class<?>> notCustomClasses)
```
    Parameters:
    
    notCustomClasses - initialize the list of classes on the non-customized list. All prior associations will be dropped and this Collection will establish the new list.
    
    Returns:
    
    WriteOptions for chained access.
  - getIncludedFields
```
public Set<String> getIncludedFields(Class<?> clazz)
```
    Get the list of fields associated to the passed in class that are to be included in the written JSON.
    
    Parameters:
    
    clazz - Class for which the fields to be included in JSON output will be returned.
    
    Returns:
    
    Set of Strings field names associated to the passed in class or an empty Set if no fields. This is the list of fields to be included in the written JSON for the given class.
  - getIncludedAccessors
```
public Set<Accessor> getIncludedAccessors(Class<?> clazz)
```
    Get the list of Accessors associated to the passed in class that are to be included in the written JSON.
    
    Parameters:
    
    clazz - Class for which the Accessors to be included in JSON output will be returned.
    
    Returns:
    
    Set of Strings Accessor names associated to the passed in class or an empty Set if no Accessors. This is the list of accessors to be included in the written JSON for the given class.
  - getIncludedFieldsPerAllClasses
```
public Map<Class<?>,Set<String>> getIncludedFieldsPerAllClasses()
```
    Returns:
    
    Map of all Classes and their associated Sets of fields to be included when serialized to JSON.
  - getIncludedAccessorsPerAllClasses
```
public Map<Class<?>,Set<Accessor>> getIncludedAccessorsPerAllClasses()
```
    Returns:
    
    Map of all Classes and their associated Sets of accessors to be included when serialized to JSON.
  - addIncludedField
```
public WriteOptions addIncludedField(Class<?> clazz,
                                     String includedField)
```
    Parameters:
    
    clazz - Class to add a single field to be included in the written JSON.
    
    includedField - String name of field to include in written JSON.
    
    Returns:
    
    WriteOptions for chained access.
  - addIncludedFields
```
public WriteOptions addIncludedFields(Class<?> clazz,
                                      Collection<String> includedFields)
```
    Parameters:
    
    clazz - Class to add a Collection of fields to be included in written JSON.
    
    includedFields - Collection of String name of fields to include in written JSON.
    
    Returns:
    
    WriteOptions for chained access.
  - addIncludedFields
```
public WriteOptions addIncludedFields(Map<Class<?>,Collection<String>> includedFields)
```
    Parameters:
    
    includedFields - Map of Class's mapped to Collection of String field names to include in the written JSON.
    
    Returns:
    
    WriteOptions for chained access.
  - addExcludedField
```
public WriteOptions addExcludedField(Class<?> clazz,
                                     String excludedField)
```
    Parameters:
    
    clazz - Class to add a single field to be excluded.
    
    excludedField - String name of field to exclude from written JSON.
    
    Returns:
    
    WriteOptions for chained access.
  - addExcludedFields
```
public WriteOptions addExcludedFields(Class<?> clazz,
                                      Collection<String> excludedFields)
```
    Parameters:
    
    clazz - Class to add a Collection of fields to be excluded in written JSON.
    
    excludedFields - Collection of String name of fields to exclude in written JSON.
    
    Returns:
    
    WriteOptions for chained access.
  - addExcludedFields
```
public WriteOptions addExcludedFields(Map<Class<?>,Collection<String>> excludedFields)
```
    Parameters:
    
    excludedFields - Map of Class's mapped to Collection of String field names to exclude from written JSON.
    
    Returns:
    
    WriteOptions for chained access.
  - getExcludedFields
```
public Set<String> getExcludedFields(Class<?> clazz)
```
    Get the list of fields associated to the passed in class that are to be excluded in the written JSON.
    
    Parameters:
    
    clazz - Class for which the fields to be excluded in JSON output will be returned.
    
    Returns:
    
    Set of Strings field names associated to the passed in class or an empty Set if no fields. This is the list of fields to be excluded in the written JSON for the given class.
  - getExcludedFieldsPerAllClasses
```
public Map<Class<?>,Set<String>> getExcludedFieldsPerAllClasses()
```
    Returns:
    
    Map of all Classes and their associated Sets of fields to be excluded when serialized to JSON.
  - getExcludedAccessors
```
public Set<Accessor> getExcludedAccessors(Class<?> clazz)
```
    Get the list of Accessors associated to the passed in class that are to be excluded in the written JSON.
    
    Parameters:
    
    clazz - Class for which the Accessors to be excluded in JSON output will be returned.
    
    Returns:
    
    Set of Strings Accessor names associated to the passed in class or an empty Set if no Accessors. This is the list of accessors to be excluded in the written JSON for the given class.
  - getIncludedAccessorsForClass
```
public Collection<Accessor> getIncludedAccessorsForClass(Class<?> c)
```
  - getExcludedAccessorsForClass
```
public Collection<Accessor> getExcludedAccessorsForClass(Class<?> c)
```
  - isoDateFormat
```
public WriteOptions isoDateFormat()
```
    Change the date-time format to the ISO date format: "yyyy-MM-dd". This is for java.util.Data and java.sql.Date.
    
    Returns:
    
    WriteOptions for chained access.
  - isoDateTimeFormat
```
public WriteOptions isoDateTimeFormat()
```
    Change the date-time format to the ISO date-time format: "yyyy-MM-dd'T'HH:mm:ss" (default). This is for java.util.Date and java.sql.Date.
    
    Returns:
    
    WriteOptions for chained access.
  - longDateFormat
```
public WriteOptions longDateFormat()
```
    Change the java.uti.Date and java.sql.Date format output to a "long," the number of seconds since Jan 1, 1970 at midnight. Useful if you do not need to see the JSON, and want to keep the format smaller. This is for java.util.Date and java.sql.Date.
    
    Returns:
    
    WriteOptions for chained access.
  - isLongDateFormat
```
public boolean isLongDateFormat()
```
    Returns:
    
    boolean true if java.util.Date and java.sql.Date's are being written in long (numeric) format.
  - dateTimeFormat
```
public WriteOptions dateTimeFormat(String format)
```
    Change the date-time format to the passed in format. The format pattens can be found in the Java Doc for the java.time.format.DateTimeFormatter class. There are many constants you can use, as well as the definition of how to construct your own patterns. This is for java.util.Date and java.sql.Date.
    
    Returns:
    
    WriteOptions for chained access.
  - isNonReferenceableClass
```
public boolean isNonReferenceableClass(Class<?> clazz)
```
    Parameters:
    
    clazz - Class to check to see if it is non-referenceable. Non-referenceable classes will always create a new instance when read in and never use @id/@ref. This uses more memory when the JSON is read in, as there will be a separate instance in memory for each occurrence. There are certain classes that json-io automatically treats as non-referenceable, like Strings, Enums, Class, and any Number instance (BigDecimal, AtomicLong, etc.) You can add to this list. Often, non-referenceable classes are useful for classes that can be defined in one line as a JSON, like a LocalDateTime, for example.
    
    Returns:
    
    boolean true if the passed in class is considered a non-referenceable class.
  - getNonReferenceableClasses
```
public Collection<Class<?>> getNonReferenceableClasses()
```
    Returns:
    
    Collection of classes specifically listed as Logical Primitives. In addition to the return classes, derivatives of Number and Date are also considered Logical Primitives by json-io.
  - addNonReferenceableClass
```
public WriteOptions addNonReferenceableClass(Class<?> clazz)
```
    Parameters:
    
    clazz - class to add to be considered a non-referenceable object. Just like an "int" for example, any class added here will never use an @id/@ref pair. The downside, is that when read, each instance, even if the same as another, will use memory.
    
    Returns:
    
    WriteOptions for chained access.
  - build
```
public WriteOptions build()
```
    Seal the instance of this class so that no more changes can be made to it.
    
    Returns:
    
    WriteOptions for chained access.
  - isBuilt
```
public boolean isBuilt()
```
    Returns:
    
    boolean true if the instance of this class is sealed, meaning no more changes can be made to it, otherwise false is returned, indicating that changes can still be made to this WriteOptions instance.
  - getCustomWriter
```
public JsonWriter.JsonClassWriter getCustomWriter(Class<?> c)
```
    Fetch the custom writer for the passed in Class. If it is cached (already associated to the passed in Class), return the same instance, otherwise, make a call to get the custom writer and store that result.
    
    Parameters:
    
    c - Class of object for which fetch a custom writer
    
    Returns:
    
    JsonClassWriter for the custom class (if one exists), null otherwise.

Class WriteOptions

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

ISO_DATE_FORMAT

ISO_DATE_TIME_FORMAT

Constructor Detail

WriteOptions

WriteOptions

Method Detail

getClassLoader

classLoader

isShortMetaKeys

shortMetaKeys

getTypeNameAlias

aliasTypeNames

aliasTypeNames

aliasTypeName

isAlwaysShowingType

isNeverShowingType

isMinimalShowingType

showTypeInfoAlways

showTypeInfoNever

showTypeInfoMinimal

isPrettyPrint

prettyPrint

isWriteLongsAsStrings

writeLongsAsStrings

isSkipNullFields

skipNullFields

isForceMapOutputAsTwoArrays

forceMapOutputAsTwoArrays

isAllowNanAndInfinity

allowNanAndInfinity

isWriteEnumAsString

isEnumPublicFieldsOnly

writeEnumsAsString

writeEnumAsJsonObject

setCustomWrittenClasses

addCustomWrittenClass

getCustomWrittenClasses

isCustomWrittenClass

isNotCustomWrittenClass

getNotCustomWrittenClasses

addNotCustomWrittenClass

setNotCustomWrittenClasses

getIncludedFields

getIncludedAccessors

getIncludedFieldsPerAllClasses

getIncludedAccessorsPerAllClasses

addIncludedField

addIncludedFields

addIncludedFields

addExcludedField

addExcludedFields

addExcludedFields

getExcludedFields

getExcludedFieldsPerAllClasses

getExcludedAccessors

getIncludedAccessorsForClass

getExcludedAccessorsForClass

isoDateFormat

isoDateTimeFormat

longDateFormat

isLongDateFormat

dateTimeFormat

isNonReferenceableClass

getNonReferenceableClasses

addNonReferenceableClass

build

isBuilt

getCustomWriter