JsonFactory (jackson-core 2.13.1)

java.lang.Object
- com.fasterxml.jackson.core.TokenStreamFactory
- - com.fasterxml.jackson.core.JsonFactory

All Implemented Interfaces:

Versioned, Serializable
```
public class JsonFactory
extends TokenStreamFactory
implements Versioned, Serializable
```
The main factory class of Jackson package, used to configure and construct reader (aka parser, JsonParser) and writer (aka generator, JsonGenerator) instances.
Factory instances are thread-safe and reusable after configuration (if any). Typically applications and services use only a single globally shared factory instance, unless they need differently configured factories. Factory reuse is important if efficiency matters; most recycling of expensive construct is done on per-factory basis.
Creation of a factory instance is a light-weight operation, and since there is no need for pluggable alternative implementations (as there is no "standard" JSON processor API to implement), the default constructor is used for constructing factory instances.

Author:

Tatu Saloranta

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class JsonFactory.Feature
Enumeration that defines all on/off features that can only be changed for JsonFactory.

Nested Classes
Modifier and Type	Class and Description
`static class`	`JsonFactory.Feature` Enumeration that defines all on/off features that can only be changed for `JsonFactory`.

Field Summary

Fields
Modifier and Type	Field and Description
`protected ByteQuadsCanonicalizer`	`_byteSymbolCanonicalizer` Alternative to the basic symbol table, some stream-based parsers use different name canonicalization method.
`protected CharacterEscapes`	`_characterEscapes` Definition of custom character escapes to use for generators created by this factory, if any.
`protected int`	`_factoryFeatures` Currently enabled factory features.
`protected int`	`_generatorFeatures` Currently enabled generator features.
`protected InputDecorator`	`_inputDecorator` Optional helper object that may decorate input sources, to do additional processing on input during parsing.
`protected int`	`_maximumNonEscapedChar` Optional threshold used for automatically escaping character above certain character code value: either `0` to indicate that no threshold is specified, or value at or above 127 to indicate last character code that is NOT automatically escaped (but depends on other configuration rules for checking).
`protected ObjectCodec`	`_objectCodec` Object that implements conversion functionality between Java objects and JSON content.
`protected OutputDecorator`	`_outputDecorator` Optional helper object that may decorate output object, to do additional processing on output during content generation.
`protected int`	`_parserFeatures` Currently enabled parser features.
`protected char`	`_quoteChar` Character used for quoting field names (if field name quoting has not been disabled with `JsonWriteFeature.QUOTE_FIELD_NAMES`) and JSON String values.
`protected CharsToNameCanonicalizer`	`_rootCharSymbols` Each factory comes equipped with a shared root symbol table.
`protected SerializableString`	`_rootValueSeparator` Separator used between root-level values, if any; null indicates "do not add separator".
`protected static int`	`DEFAULT_FACTORY_FEATURE_FLAGS` Bitfield (set of flags) of all factory features that are enabled by default.
`protected static int`	`DEFAULT_GENERATOR_FEATURE_FLAGS` Bitfield (set of flags) of all generator features that are enabled by default.
`protected static int`	`DEFAULT_PARSER_FEATURE_FLAGS` Bitfield (set of flags) of all parser features that are enabled by default.
`static char`	`DEFAULT_QUOTE_CHAR`
`static SerializableString`	`DEFAULT_ROOT_VALUE_SEPARATOR`
`static String`	`FORMAT_NAME_JSON` Name used to identify JSON format (and returned by `getFormatName()`

Constructor Summary

Constructors
Modifier	Constructor and Description
	`JsonFactory()` Default constructor used to create factory instances.
	`JsonFactory(JsonFactoryBuilder b)` Constructor used by `JsonFactoryBuilder` for instantiation.
`protected`	`JsonFactory(JsonFactory src, ObjectCodec codec)` Constructor used when copy()ing a factory instance.
	`JsonFactory(ObjectCodec oc)`
`protected`	`JsonFactory(TSFBuilder<?,?> b, boolean bogus)` Constructor for subtypes; needed to work around the fact that before 3.0, this factory has cumbersome dual role as generic type as well as actual implementation for json.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`protected void`	`_checkInvalidCopy(Class<?> exp)`
`protected ContentReference`	`_createContentReference(Object contentAccessor)` Overridable factory method for constructing `ContentReference` to pass to parser or generator being created; used in cases where no offset or length is applicable (either irrelevant, or full contents assumed).
`protected ContentReference`	`_createContentReference(Object contentAccessor, int offset, int length)` Overridable factory method for constructing `ContentReference` to pass to parser or generator being created; used in cases where content is available in a static buffer with relevant offset and length (mostly when reading from `byte[]`, `char[]` or `String`).
`protected IOContext`	`_createContext(ContentReference contentRef, boolean resourceManaged)` Overridable factory method that actually instantiates desired context object.
`protected IOContext`	`_createContext(Object rawContentRef, boolean resourceManaged)` Deprecated. Since 2.13
`protected JsonGenerator`	`_createGenerator(Writer out, IOContext ctxt)` Overridable factory method that actually instantiates generator for given `Writer` and context object.
`protected IOContext`	`_createNonBlockingContext(Object srcRef)` Overridable factory method that actually instantiates desired context object for async (non-blocking) parsing
`protected JsonParser`	`_createParser(byte[] data, int offset, int len, IOContext ctxt)` Overridable factory method that actually instantiates parser using given `Reader` object for reading content passed as raw byte array.
`protected JsonParser`	`_createParser(char[] data, int offset, int len, IOContext ctxt, boolean recyclable)` Overridable factory method that actually instantiates parser using given `char[]` object for accessing content.
`protected JsonParser`	`_createParser(DataInput input, IOContext ctxt)` Optional factory method, expected to be overridden
`protected JsonParser`	`_createParser(InputStream in, IOContext ctxt)` Overridable factory method that actually instantiates desired parser given `InputStream` and context object.
`protected JsonParser`	`_createParser(Reader r, IOContext ctxt)` Overridable factory method that actually instantiates parser using given `Reader` object for reading content.
`protected JsonGenerator`	`_createUTF8Generator(OutputStream out, IOContext ctxt)` Overridable factory method that actually instantiates generator for given `OutputStream` and context object, using UTF-8 encoding.
`protected Writer`	`_createWriter(OutputStream out, JsonEncoding enc, IOContext ctxt)`
`protected DataInput`	`_decorate(DataInput in, IOContext ctxt)`
`protected InputStream`	`_decorate(InputStream in, IOContext ctxt)`
`protected OutputStream`	`_decorate(OutputStream out, IOContext ctxt)`
`protected Reader`	`_decorate(Reader in, IOContext ctxt)`
`protected Writer`	`_decorate(Writer out, IOContext ctxt)`
`BufferRecycler`	`_getBufferRecycler()` Method used by factory to create buffer recycler instances for parsers and generators.
`static TSFBuilder<?,?>`	`builder()` Main factory method to use for constructing `JsonFactory` instances with different configuration: creates and returns a builder for collecting configuration settings; instance created by calling `build()` after all configuration set.
`boolean`	`canHandleBinaryNatively()` Introspection method that higher-level functionality may call to see whether underlying data format can read and write binary data natively; that is, embeded it as-is without using encodings such as Base64.
`boolean`	`canParseAsync()` Introspection method that can be used to check whether this factory can create non-blocking parsers: parsers that do not use blocking I/O abstractions but instead use a `NonBlockingInputFeeder`.
`boolean`	`canUseCharArrays()` Introspection method that can be used by base factory to check whether access using `char[]` is something that actual parser implementations can take advantage of, over having to use `Reader`.
`boolean`	`canUseSchema(FormatSchema schema)` Method that can be used to quickly check whether given schema is something that parsers and/or generators constructed by this factory could use.
`JsonFactory`	`configure(JsonFactory.Feature f, boolean state)` Deprecated. since 2.10 use `TSFBuilder.configure(JsonFactory.Feature, boolean)` instead
`JsonFactory`	`configure(JsonGenerator.Feature f, boolean state)` Method for enabling or disabling specified generator feature (check `JsonGenerator.Feature` for list of features)
`JsonFactory`	`configure(JsonParser.Feature f, boolean state)` Method for enabling or disabling specified parser feature (check `JsonParser.Feature` for list of features)
`JsonFactory`	`copy()` Method for constructing a new `JsonFactory` that has the same settings as this instance, but is otherwise independent (i.e.
`JsonGenerator`	`createGenerator(DataOutput out)` Convenience method for constructing generator that uses default encoding of the format (UTF-8 for JSON and most other data formats).
`JsonGenerator`	`createGenerator(DataOutput out, JsonEncoding enc)` Method for constructing generator for writing content using specified `DataOutput` instance.
`JsonGenerator`	`createGenerator(File f, JsonEncoding enc)` Method for constructing JSON generator for writing JSON content to specified file, overwriting contents it might have (or creating it if such file does not yet exist).
`JsonGenerator`	`createGenerator(OutputStream out)` Convenience method for constructing generator that uses default encoding of the format (UTF-8 for JSON and most other data formats).
`JsonGenerator`	`createGenerator(OutputStream out, JsonEncoding enc)` Method for constructing JSON generator for writing JSON content using specified output stream.
`JsonGenerator`	`createGenerator(Writer w)` Method for constructing JSON generator for writing JSON content using specified Writer.
`JsonGenerator`	`createJsonGenerator(OutputStream out)` Deprecated. Since 2.2, use `createGenerator(OutputStream)` instead.
`JsonGenerator`	`createJsonGenerator(OutputStream out, JsonEncoding enc)` Deprecated. Since 2.2, use `createGenerator(OutputStream, JsonEncoding)` instead.
`JsonGenerator`	`createJsonGenerator(Writer out)` Deprecated. Since 2.2, use `createGenerator(Writer)` instead.
`JsonParser`	`createJsonParser(byte[] data)` Deprecated. Since 2.2, use `createParser(byte[])` instead.
`JsonParser`	`createJsonParser(byte[] data, int offset, int len)` Deprecated. Since 2.2, use `createParser(byte[],int,int)` instead.
`JsonParser`	`createJsonParser(File f)` Deprecated. Since 2.2, use `createParser(File)` instead.
`JsonParser`	`createJsonParser(InputStream in)` Deprecated. Since 2.2, use `createParser(InputStream)` instead.
`JsonParser`	`createJsonParser(Reader r)` Deprecated. Since 2.2, use `createParser(Reader)` instead.
`JsonParser`	`createJsonParser(String content)` Deprecated. Since 2.2, use `createParser(String)` instead.
`JsonParser`	`createJsonParser(URL url)` Deprecated. Since 2.2, use `createParser(URL)` instead.
`JsonParser`	`createNonBlockingByteArrayParser()` Optional method for constructing parser for non-blocking parsing via `ByteArrayFeeder` interface (accessed using `JsonParser.getNonBlockingInputFeeder()` from constructed instance).
`JsonParser`	`createParser(byte[] data)` Method for constructing parser for parsing the contents of given byte array.
`JsonParser`	`createParser(byte[] data, int offset, int len)` Method for constructing parser for parsing the contents of given byte array.
`JsonParser`	`createParser(char[] content)` Method for constructing parser for parsing contents of given char array.
`JsonParser`	`createParser(char[] content, int offset, int len)` Method for constructing parser for parsing contents of given char array.
`JsonParser`	`createParser(DataInput in)` Optional method for constructing parser for reading contents from specified `DataInput` instance.
`JsonParser`	`createParser(File f)` Method for constructing JSON parser instance to parse contents of specified file.
`JsonParser`	`createParser(InputStream in)` Method for constructing JSON parser instance to parse the contents accessed via specified input stream.
`JsonParser`	`createParser(Reader r)` Method for constructing parser for parsing the contents accessed via specified Reader.
`JsonParser`	`createParser(String content)` Method for constructing parser for parsing contents of given String.
`JsonParser`	`createParser(URL url)` Method for constructing JSON parser instance to parse contents of resource reference by given URL.
`JsonFactory`	`disable(JsonFactory.Feature f)` Deprecated. since 2.10 use `TSFBuilder.configure(JsonFactory.Feature, boolean)` instead
`JsonFactory`	`disable(JsonGenerator.Feature f)` Method for disabling specified generator feature (check `JsonGenerator.Feature` for list of features)
`JsonFactory`	`disable(JsonParser.Feature f)` Method for disabling specified parser features (check `JsonParser.Feature` for list of features)
`JsonFactory`	`enable(JsonFactory.Feature f)` Deprecated. since 2.10 use `TSFBuilder.configure(JsonFactory.Feature, boolean)` instead
`JsonFactory`	`enable(JsonGenerator.Feature f)` Method for enabling specified generator features (check `JsonGenerator.Feature` for list of features)
`JsonFactory`	`enable(JsonParser.Feature f)` Method for enabling specified parser feature (check `JsonParser.Feature` for list of features)
`CharacterEscapes`	`getCharacterEscapes()` Method for accessing custom escapes factory uses for `JsonGenerator`s it creates.
`ObjectCodec`	`getCodec()`
`int`	`getFormatGeneratorFeatures()`
`String`	`getFormatName()` Method that returns short textual id identifying format this factory supports.
`int`	`getFormatParserFeatures()`
`Class<? extends FormatFeature>`	`getFormatReadFeatureType()` Method for accessing kind of `FormatFeature` that a parser `JsonParser` produced by this factory would accept, if any; `null` returned if none.
`Class<? extends FormatFeature>`	`getFormatWriteFeatureType()` Method for accessing kind of `FormatFeature` that a parser `JsonGenerator` produced by this factory would accept, if any; `null` returned if none.
`int`	`getGeneratorFeatures()`
`InputDecorator`	`getInputDecorator()` Method for getting currently configured input decorator (if any; there is no default decorator).
`OutputDecorator`	`getOutputDecorator()` Method for getting currently configured output decorator (if any; there is no default decorator).
`int`	`getParserFeatures()`
`String`	`getRootValueSeparator()`
`MatchStrength`	`hasFormat(InputAccessor acc)`
`protected MatchStrength`	`hasJSONFormat(InputAccessor acc)`
`boolean`	`isEnabled(JsonFactory.Feature f)` Checked whether specified parser feature is enabled.
`boolean`	`isEnabled(JsonGenerator.Feature f)` Check whether specified generator feature is enabled.
`boolean`	`isEnabled(JsonParser.Feature f)` Method for checking if the specified parser feature is enabled.
`boolean`	`isEnabled(StreamReadFeature f)` Method for checking if the specified stream read feature is enabled.
`boolean`	`isEnabled(StreamWriteFeature f)` Check whether specified stream write feature is enabled.
`protected Object`	`readResolve()` Method that we need to override to actually make restoration go through constructors etc: needed to allow JDK serializability of factory instances.
`TSFBuilder<?,?>`	`rebuild()` Method that allows construction of differently configured factory, starting with settings of this factory.
`boolean`	`requiresCustomCodec()` Method that can be called to determine if a custom `ObjectCodec` is needed for binding data parsed using `JsonParser` constructed by this factory (which typically also implies the same for serialization with `JsonGenerator`).
`boolean`	`requiresPropertyOrdering()` Introspection method that higher-level functionality may call to see whether underlying data format requires a stable ordering of object properties or not.
`JsonFactory`	`setCharacterEscapes(CharacterEscapes esc)` Method for defining custom escapes factory uses for `JsonGenerator`s it creates.
`JsonFactory`	`setCodec(ObjectCodec oc)` Method for associating a `ObjectCodec` (typically a `com.fasterxml.jackson.databind.ObjectMapper`) with this factory (and more importantly, parsers and generators it constructs).
`JsonFactory`	`setInputDecorator(InputDecorator d)` Deprecated. Since 2.10 use `TSFBuilder.inputDecorator(InputDecorator)` instead
`JsonFactory`	`setOutputDecorator(OutputDecorator d)` Deprecated. Since 2.10 use `TSFBuilder.outputDecorator(OutputDecorator)` instead
`JsonFactory`	`setRootValueSeparator(String sep)` Method that allows overriding String used for separating root-level JSON values (default is single space character)
`Version`	`version()` Method called to detect version of the component that implements this interface; returned version should never be null, but may return specific "not available" instance (see `Version` for details).

Methods inherited from class com.fasterxml.jackson.core.TokenStreamFactory
_createDataOutputWrapper, _optimizedStreamFromURL

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

- Field Detail
  - FORMAT_NAME_JSON
```
public static final String FORMAT_NAME_JSON
```
    Name used to identify JSON format (and returned by getFormatName()
    
    See Also:
    
    Constant Field Values
  - DEFAULT_FACTORY_FEATURE_FLAGS
```
protected static final int DEFAULT_FACTORY_FEATURE_FLAGS
```
    Bitfield (set of flags) of all factory features that are enabled by default.
  - DEFAULT_PARSER_FEATURE_FLAGS
```
protected static final int DEFAULT_PARSER_FEATURE_FLAGS
```
    Bitfield (set of flags) of all parser features that are enabled by default.
  - DEFAULT_GENERATOR_FEATURE_FLAGS
```
protected static final int DEFAULT_GENERATOR_FEATURE_FLAGS
```
    Bitfield (set of flags) of all generator features that are enabled by default.
  - DEFAULT_ROOT_VALUE_SEPARATOR
```
public static final SerializableString DEFAULT_ROOT_VALUE_SEPARATOR
```
  - DEFAULT_QUOTE_CHAR
```
public static final char DEFAULT_QUOTE_CHAR
```
    Since:
    
    2.10
    
    See Also:
    
    Constant Field Values
  - _rootCharSymbols
```
protected final transient CharsToNameCanonicalizer _rootCharSymbols
```
    Each factory comes equipped with a shared root symbol table. It should not be linked back to the original blueprint, to avoid contents from leaking between factories.
  - _byteSymbolCanonicalizer
```
protected final transient ByteQuadsCanonicalizer _byteSymbolCanonicalizer
```
    Alternative to the basic symbol table, some stream-based parsers use different name canonicalization method.
    TODO: should clean up this; looks messy having 2 alternatives with not very clear differences.
    
    Since:
    
    2.6
  - _factoryFeatures
```
protected int _factoryFeatures
```
    Currently enabled factory features.
  - _parserFeatures
```
protected int _parserFeatures
```
    Currently enabled parser features.
  - _generatorFeatures
```
protected int _generatorFeatures
```
    Currently enabled generator features.
  - _objectCodec
```
protected ObjectCodec _objectCodec
```
    Object that implements conversion functionality between Java objects and JSON content. For base JsonFactory implementation usually not set by default, but can be explicitly set. Sub-classes (like @link org.codehaus.jackson.map.MappingJsonFactory} usually provide an implementation.
  - _characterEscapes
```
protected CharacterEscapes _characterEscapes
```
    Definition of custom character escapes to use for generators created by this factory, if any. If null, standard data format specific escapes are used.
  - _inputDecorator
```
protected InputDecorator _inputDecorator
```
    Optional helper object that may decorate input sources, to do additional processing on input during parsing.
  - _outputDecorator
```
protected OutputDecorator _outputDecorator
```
    Optional helper object that may decorate output object, to do additional processing on output during content generation.
  - _rootValueSeparator
```
protected SerializableString _rootValueSeparator
```
    Separator used between root-level values, if any; null indicates "do not add separator". Default separator is a single space character.
    
    Since:
    
    2.1
  - _maximumNonEscapedChar
```
protected int _maximumNonEscapedChar
```
    Optional threshold used for automatically escaping character above certain character code value: either 0 to indicate that no threshold is specified, or value at or above 127 to indicate last character code that is NOT automatically escaped (but depends on other configuration rules for checking).
    
    Since:
    
    2.10
  - _quoteChar
```
protected final char _quoteChar
```
    Character used for quoting field names (if field name quoting has not been disabled with JsonWriteFeature.QUOTE_FIELD_NAMES) and JSON String values.
- Constructor Detail
  - JsonFactory
```
public JsonFactory()
```
    Default constructor used to create factory instances. Creation of a factory instance is a light-weight operation, but it is still a good idea to reuse limited number of factory instances (and quite often just a single instance): factories are used as context for storing some reused processing objects (such as symbol tables parsers use) and this reuse only works within context of a single factory instance.
  - JsonFactory
```
public JsonFactory(ObjectCodec oc)
```
  - JsonFactory
```
protected JsonFactory(JsonFactory src,
                      ObjectCodec codec)
```
    Constructor used when copy()ing a factory instance.
    
    Parameters:
    
    src - Original factory to copy settings from
    
    codec - Databinding-level codec to use, if any
    
    Since:
    
    2.2.1
  - JsonFactory
```
public JsonFactory(JsonFactoryBuilder b)
```
    Constructor used by JsonFactoryBuilder for instantiation.
    
    Parameters:
    
    b - Builder that contains settings to use
    
    Since:
    
    2.10
  - JsonFactory
```
protected JsonFactory(TSFBuilder<?,?> b,
                      boolean bogus)
```
    Constructor for subtypes; needed to work around the fact that before 3.0, this factory has cumbersome dual role as generic type as well as actual implementation for json.
    
    Parameters:
    
    b - Builder that contains settings to use
    
    bogus - Argument only needed to separate constructor signature; ignored
- Method Detail
  - rebuild
```
public TSFBuilder<?,?> rebuild()
```
    Method that allows construction of differently configured factory, starting with settings of this factory.
    
    Returns:
    
    Builder instance to use
    
    Since:
    
    2.10
  - builder
```
public static TSFBuilder<?,?> builder()
```
    Main factory method to use for constructing JsonFactory instances with different configuration: creates and returns a builder for collecting configuration settings; instance created by calling build() after all configuration set.
    NOTE: signature unfortunately does not expose true implementation type; this will be fixed in 3.0.
    
    Returns:
    
    Builder instance to use
  - copy
```
public JsonFactory copy()
```
    Method for constructing a new JsonFactory that has the same settings as this instance, but is otherwise independent (i.e. nothing is actually shared, symbol tables are separate). Note that ObjectCodec reference is not copied but is set to null; caller typically needs to set it after calling this method. Reason for this is that the codec is used for callbacks, and assumption is that there is strict 1-to-1 mapping between codec, factory. Caller has to, then, explicitly set codec after making the copy.
    
    Returns:
    
    Copy of this factory instance
    
    Since:
    
    2.1
  - _checkInvalidCopy
```
protected void _checkInvalidCopy(Class<?> exp)
```
  - readResolve
```
protected Object readResolve()
```
    Method that we need to override to actually make restoration go through constructors etc: needed to allow JDK serializability of factory instances.
    Note: must be overridden by sub-classes as well.
    
    Returns:
    
    Newly constructed instance
  - requiresPropertyOrdering
```
public boolean requiresPropertyOrdering()
```
    Introspection method that higher-level functionality may call to see whether underlying data format requires a stable ordering of object properties or not. This is usually used for determining whether to force a stable ordering (like alphabetic ordering by name) if no ordering if explicitly specified.
    Default implementation returns false as JSON does NOT require stable ordering. Formats that require ordering include positional textual formats like CSV, and schema-based binary formats like Avro.
    
    Specified by:
    
    requiresPropertyOrdering in class TokenStreamFactory
    
    Returns:
    
    Whether format supported by this factory requires Object properties to be ordered.
    
    Since:
    
    2.3
  - canHandleBinaryNatively
```
public boolean canHandleBinaryNatively()
```
    Introspection method that higher-level functionality may call to see whether underlying data format can read and write binary data natively; that is, embeded it as-is without using encodings such as Base64.
    Default implementation returns false as JSON does not support native access: all binary content must use Base64 encoding. Most binary formats (like Smile and Avro) support native binary content.
    
    Specified by:
    
    canHandleBinaryNatively in class TokenStreamFactory
    
    Returns:
    
    Whether format supported by this factory supports native binary content
    
    Since:
    
    2.3
  - canUseCharArrays
```
public boolean canUseCharArrays()
```
    Introspection method that can be used by base factory to check whether access using char[] is something that actual parser implementations can take advantage of, over having to use Reader. Sub-types are expected to override definition; default implementation (suitable for JSON) alleges that optimization are possible; and thereby is likely to try to access String content by first copying it into recyclable intermediate buffer.
    
    Returns:
    
    Whether access to decoded textual content can be efficiently accessed using parser method getTextCharacters().
    
    Since:
    
    2.4
  - canParseAsync
```
public boolean canParseAsync()
```
    Introspection method that can be used to check whether this factory can create non-blocking parsers: parsers that do not use blocking I/O abstractions but instead use a NonBlockingInputFeeder.
    
    Specified by:
    
    canParseAsync in class TokenStreamFactory
    
    Returns:
    
    Whether this factory supports non-blocking ("async") parsing or not (and consequently whether createNonBlockingXxx() method(s) work)
    
    Since:
    
    2.9
  - getFormatReadFeatureType
```
public Class<? extends FormatFeature> getFormatReadFeatureType()
```
    Description copied from class: TokenStreamFactory
    
    Method for accessing kind of FormatFeature that a parser JsonParser produced by this factory would accept, if any; null returned if none.
    
    Specified by:
    
    getFormatReadFeatureType in class TokenStreamFactory
    
    Returns:
    
    Type of format-specific stream read features, if any; null if none
  - getFormatWriteFeatureType
```
public Class<? extends FormatFeature> getFormatWriteFeatureType()
```
    Description copied from class: TokenStreamFactory
    
    Method for accessing kind of FormatFeature that a parser JsonGenerator produced by this factory would accept, if any; null returned if none.
    
    Specified by:
    
    getFormatWriteFeatureType in class TokenStreamFactory
    
    Returns:
    
    Type of format-specific stream read features, if any; null if none
  - canUseSchema
```
public boolean canUseSchema(FormatSchema schema)
```
    Method that can be used to quickly check whether given schema is something that parsers and/or generators constructed by this factory could use. Note that this means possible use, at the level of data format (i.e. schema is for same data format as parsers and generators this factory constructs); individual schema instances may have further usage restrictions.
    
    Specified by:
    
    canUseSchema in class TokenStreamFactory
    
    Parameters:
    
    schema - Schema instance to check
    
    Returns:
    
    Whether parsers and generators constructed by this factory can use specified format schema instance
  - getFormatName
```
public String getFormatName()
```
    Method that returns short textual id identifying format this factory supports.
    Note: sub-classes should override this method; default implementation will return null for all sub-classes
    
    Specified by:
    
    getFormatName in class TokenStreamFactory
    
    Returns:
    
    Name of the format handled by parsers, generators this factory creates
  - hasFormat
```
public MatchStrength hasFormat(InputAccessor acc)
                        throws IOException
```
    Throws:
    
    IOException
  - requiresCustomCodec
```
public boolean requiresCustomCodec()
```
    Method that can be called to determine if a custom ObjectCodec is needed for binding data parsed using JsonParser constructed by this factory (which typically also implies the same for serialization with JsonGenerator).
    
    Returns:
    
    True if custom codec is needed with parsers and generators created by this factory; false if a general ObjectCodec is enough
    
    Since:
    
    2.1
  - hasJSONFormat
```
protected MatchStrength hasJSONFormat(InputAccessor acc)
                               throws IOException
```
    Throws:
    
    IOException
  - version
```
public Version version()
```
    Description copied from interface: Versioned
    
    Method called to detect version of the component that implements this interface; returned version should never be null, but may return specific "not available" instance (see Version for details).
    
    Specified by:
    
    version in interface Versioned
    
    Returns:
    
    Version of the component
  - configure
```
@Deprecated
public final JsonFactory configure(JsonFactory.Feature f,
                                               boolean state)
```
    Deprecated. since 2.10 use TSFBuilder.configure(JsonFactory.Feature, boolean) instead
    
    Method for enabling or disabling specified parser feature (check JsonParser.Feature for list of features)
    
    Parameters:
    
    f - Feature to enable/disable
    
    state - Whether to enable or disable the feature
    
    Returns:
    
    This factory instance (to allow call chaining)
  - enable
```
@Deprecated
public JsonFactory enable(JsonFactory.Feature f)
```
    Deprecated. since 2.10 use TSFBuilder.configure(JsonFactory.Feature, boolean) instead
    
    Method for enabling specified parser feature (check JsonFactory.Feature for list of features)
    
    Parameters:
    
    f - Feature to enable
    
    Returns:
    
    This factory instance (to allow call chaining)
  - disable
```
@Deprecated
public JsonFactory disable(JsonFactory.Feature f)
```
    Deprecated. since 2.10 use TSFBuilder.configure(JsonFactory.Feature, boolean) instead
    
    Method for disabling specified parser features (check JsonFactory.Feature for list of features)
    
    Parameters:
    
    f - Feature to disable
    
    Returns:
    
    This factory instance (to allow call chaining)
  - isEnabled
```
public final boolean isEnabled(JsonFactory.Feature f)
```
    Checked whether specified parser feature is enabled.
    
    Parameters:
    
    f - Feature to check
    
    Returns:
    
    True if the specified feature is enabled
  - getParserFeatures
```
public final int getParserFeatures()
```
    Specified by:
    
    getParserFeatures in class TokenStreamFactory
  - getGeneratorFeatures
```
public final int getGeneratorFeatures()
```
    Specified by:
    
    getGeneratorFeatures in class TokenStreamFactory
  - getFormatParserFeatures
```
public int getFormatParserFeatures()
```
    Specified by:
    
    getFormatParserFeatures in class TokenStreamFactory
  - getFormatGeneratorFeatures
```
public int getFormatGeneratorFeatures()
```
    Specified by:
    
    getFormatGeneratorFeatures in class TokenStreamFactory
  - configure
```
public final JsonFactory configure(JsonParser.Feature f,
                                   boolean state)
```
    Method for enabling or disabling specified parser feature (check JsonParser.Feature for list of features)
    
    Parameters:
    
    f - Feature to enable/disable
    
    state - Whether to enable or disable the feature
    
    Returns:
    
    This factory instance (to allow call chaining)
  - enable
```
public JsonFactory enable(JsonParser.Feature f)
```
    Method for enabling specified parser feature (check JsonParser.Feature for list of features)
    
    Parameters:
    
    f - Feature to enable
    
    Returns:
    
    This factory instance (to allow call chaining)
  - disable
```
public JsonFactory disable(JsonParser.Feature f)
```
    Method for disabling specified parser features (check JsonParser.Feature for list of features)
    
    Parameters:
    
    f - Feature to disable
    
    Returns:
    
    This factory instance (to allow call chaining)
  - isEnabled
```
public final boolean isEnabled(JsonParser.Feature f)
```
    Method for checking if the specified parser feature is enabled.
    
    Specified by:
    
    isEnabled in class TokenStreamFactory
    
    Parameters:
    
    f - Feature to check
    
    Returns:
    
    True if specified feature is enabled
  - isEnabled
```
public final boolean isEnabled(StreamReadFeature f)
```
    Method for checking if the specified stream read feature is enabled.
    
    Parameters:
    
    f - Feature to check
    
    Returns:
    
    True if specified feature is enabled
    
    Since:
    
    2.10
  - getInputDecorator
```
public InputDecorator getInputDecorator()
```
    Method for getting currently configured input decorator (if any; there is no default decorator).
    
    Returns:
    
    InputDecorator configured, if any
  - setInputDecorator
```
@Deprecated
public JsonFactory setInputDecorator(InputDecorator d)
```
    Deprecated. Since 2.10 use TSFBuilder.inputDecorator(InputDecorator) instead
    
    Method for overriding currently configured input decorator
    
    Parameters:
    
    d - Decorator to configure for this factory, if any (null if none)
    
    Returns:
    
    This factory instance (to allow call chaining)
  - configure
```
public final JsonFactory configure(JsonGenerator.Feature f,
                                   boolean state)
```
    Method for enabling or disabling specified generator feature (check JsonGenerator.Feature for list of features)
    
    Parameters:
    
    f - Feature to enable/disable
    
    state - Whether to enable or disable the feature
    
    Returns:
    
    This factory instance (to allow call chaining)
  - enable
```
public JsonFactory enable(JsonGenerator.Feature f)
```
    Method for enabling specified generator features (check JsonGenerator.Feature for list of features)
    
    Parameters:
    
    f - Feature to enable
    
    Returns:
    
    This factory instance (to allow call chaining)
  - disable
```
public JsonFactory disable(JsonGenerator.Feature f)
```
    Method for disabling specified generator feature (check JsonGenerator.Feature for list of features)
    
    Parameters:
    
    f - Feature to disable
    
    Returns:
    
    This factory instance (to allow call chaining)
  - isEnabled
```
public final boolean isEnabled(JsonGenerator.Feature f)
```
    Check whether specified generator feature is enabled.
    
    Specified by:
    
    isEnabled in class TokenStreamFactory
    
    Parameters:
    
    f - Feature to check
    
    Returns:
    
    Whether specified feature is enabled
  - isEnabled
```
public final boolean isEnabled(StreamWriteFeature f)
```
    Check whether specified stream write feature is enabled.
    
    Parameters:
    
    f - Feature to check
    
    Returns:
    
    Whether specified feature is enabled
    
    Since:
    
    2.10
  - getCharacterEscapes
```
public CharacterEscapes getCharacterEscapes()
```
    Method for accessing custom escapes factory uses for JsonGenerators it creates.
    
    Returns:
    
    Configured CharacterEscapes, if any; null if none
  - setCharacterEscapes
```
public JsonFactory setCharacterEscapes(CharacterEscapes esc)
```
    Method for defining custom escapes factory uses for JsonGenerators it creates.
    
    Parameters:
    
    esc - CharaterEscapes to set (or null for "none")
    
    Returns:
    
    This factory instance (to allow call chaining)
  - getOutputDecorator
```
public OutputDecorator getOutputDecorator()
```
    Method for getting currently configured output decorator (if any; there is no default decorator).
    
    Returns:
    
    OutputDecorator configured for generators factory creates, if any; null if none.
  - setOutputDecorator
```
@Deprecated
public JsonFactory setOutputDecorator(OutputDecorator d)
```
    Deprecated. Since 2.10 use TSFBuilder.outputDecorator(OutputDecorator) instead
    
    Method for overriding currently configured output decorator
    
    Parameters:
    
    d - Output decorator to use, if any
    
    Returns:
    
    This factory instance (to allow call chaining)
  - setRootValueSeparator
```
public JsonFactory setRootValueSeparator(String sep)
```
    Method that allows overriding String used for separating root-level JSON values (default is single space character)
    
    Parameters:
    
    sep - Separator to use, if any; null means that no separator is automatically added
    
    Returns:
    
    This factory instance (to allow call chaining)
  - getRootValueSeparator
```
public String getRootValueSeparator()
```
    Returns:
    
    Root value separator configured, if any
  - setCodec
```
public JsonFactory setCodec(ObjectCodec oc)
```
    Method for associating a ObjectCodec (typically a com.fasterxml.jackson.databind.ObjectMapper) with this factory (and more importantly, parsers and generators it constructs). This is needed to use data-binding methods of JsonParser and JsonGenerator instances.
    
    Parameters:
    
    oc - Codec to use
    
    Returns:
    
    This factory instance (to allow call chaining)
  - getCodec
```
public ObjectCodec getCodec()
```
  - createParser
```
public JsonParser createParser(File f)
                        throws IOException,
                               JsonParseException
```
    Method for constructing JSON parser instance to parse contents of specified file.
    Encoding is auto-detected from contents according to JSON specification recommended mechanism. Json specification supports only UTF-8, UTF-16 and UTF-32 as valid encodings, so auto-detection implemented only for this charsets. For other charsets use createParser(java.io.Reader).
    Underlying input stream (needed for reading contents) will be owned (and managed, i.e. closed as need be) by the parser, since caller has no access to it.
    
    Specified by:
    
    createParser in class TokenStreamFactory
    
    Parameters:
    
    f - File that contains JSON content to parse
    
    Throws:
    
    IOException
    
    JsonParseException
    
    Since:
    
    2.1
  - createParser
```
public JsonParser createParser(URL url)
                        throws IOException,
                               JsonParseException
```
    Method for constructing JSON parser instance to parse contents of resource reference by given URL.
    Encoding is auto-detected from contents according to JSON specification recommended mechanism. Json specification supports only UTF-8, UTF-16 and UTF-32 as valid encodings, so auto-detection implemented only for this charsets. For other charsets use createParser(java.io.Reader).
    Underlying input stream (needed for reading contents) will be owned (and managed, i.e. closed as need be) by the parser, since caller has no access to it.
    
    Specified by:
    
    createParser in class TokenStreamFactory
    
    Parameters:
    
    url - URL pointing to resource that contains JSON content to parse
    
    Throws:
    
    IOException
    
    JsonParseException
    
    Since:
    
    2.1
  - createParser
```
public JsonParser createParser(InputStream in)
                        throws IOException,
                               JsonParseException
```
    Method for constructing JSON parser instance to parse the contents accessed via specified input stream.
    The input stream will not be owned by the parser, it will still be managed (i.e. closed if end-of-stream is reacher, or parser close method called) if (and only if) StreamReadFeature.AUTO_CLOSE_SOURCE is enabled.
    Note: no encoding argument is taken since it can always be auto-detected as suggested by JSON RFC. Json specification supports only UTF-8, UTF-16 and UTF-32 as valid encodings, so auto-detection implemented only for this charsets. For other charsets use createParser(java.io.Reader).
    
    Specified by:
    
    createParser in class TokenStreamFactory
    
    Parameters:
    
    in - InputStream to use for reading JSON content to parse
    
    Throws:
    
    IOException
    
    JsonParseException
    
    Since:
    
    2.1
  - createParser
```
public JsonParser createParser(Reader r)
                        throws IOException,
                               JsonParseException
```
    Method for constructing parser for parsing the contents accessed via specified Reader.
    The read stream will not be owned by the parser, it will still be managed (i.e. closed if end-of-stream is reacher, or parser close method called) if (and only if) StreamReadFeature.AUTO_CLOSE_SOURCE is enabled.
    
    Specified by:
    
    createParser in class TokenStreamFactory
    
    Parameters:
    
    r - Reader to use for reading JSON content to parse
    
    Throws:
    
    IOException
    
    JsonParseException
    
    Since:
    
    2.1
  - createParser
```
public JsonParser createParser(byte[] data)
                        throws IOException,
                               JsonParseException
```
    Method for constructing parser for parsing the contents of given byte array.
    
    Specified by:
    
    createParser in class TokenStreamFactory
    
    Throws:
    
    IOException
    
    JsonParseException
    
    Since:
    
    2.1
  - createParser
```
public JsonParser createParser(byte[] data,
                               int offset,
                               int len)
                        throws IOException,
                               JsonParseException
```
    Method for constructing parser for parsing the contents of given byte array.
    
    Specified by:
    
    createParser in class TokenStreamFactory
    
    Parameters:
    
    data - Buffer that contains data to parse
    
    offset - Offset of the first data byte within buffer
    
    len - Length of contents to parse within buffer
    
    Throws:
    
    IOException
    
    JsonParseException
    
    Since:
    
    2.1
  - createParser
```
public JsonParser createParser(String content)
                        throws IOException,
                               JsonParseException
```
    Method for constructing parser for parsing contents of given String.
    
    Specified by:
    
    createParser in class TokenStreamFactory
    
    Throws:
    
    IOException
    
    JsonParseException
    
    Since:
    
    2.1
  - createParser
```
public JsonParser createParser(char[] content)
                        throws IOException
```
    Method for constructing parser for parsing contents of given char array.
    
    Specified by:
    
    createParser in class TokenStreamFactory
    
    Throws:
    
    IOException
    
    Since:
    
    2.4
  - createParser
```
public JsonParser createParser(char[] content,
                               int offset,
                               int len)
                        throws IOException
```
    Method for constructing parser for parsing contents of given char array.
    
    Specified by:
    
    createParser in class TokenStreamFactory
    
    Throws:
    
    IOException
    
    Since:
    
    2.4
  - createParser
```
public JsonParser createParser(DataInput in)
                        throws IOException
```
    Optional method for constructing parser for reading contents from specified DataInput instance.
    If this factory does not support DataInput as source, will throw UnsupportedOperationException
    
    Specified by:
    
    createParser in class TokenStreamFactory
    
    Throws:
    
    IOException
    
    Since:
    
    2.8
  - createNonBlockingByteArrayParser
```
public JsonParser createNonBlockingByteArrayParser()
                                            throws IOException
```
    Optional method for constructing parser for non-blocking parsing via ByteArrayFeeder interface (accessed using JsonParser.getNonBlockingInputFeeder() from constructed instance).
    If this factory does not support non-blocking parsing (either at all, or from byte array), will throw UnsupportedOperationException.
    Note that JSON-backed factory only supports parsing of UTF-8 encoded JSON content (and US-ASCII since it is proper subset); other encodings are not supported at this point.
    
    Specified by:
    
    createNonBlockingByteArrayParser in class TokenStreamFactory
    
    Throws:
    
    IOException
    
    Since:
    
    2.9
  - createGenerator
```
public JsonGenerator createGenerator(OutputStream out,
                                     JsonEncoding enc)
                              throws IOException
```
    Method for constructing JSON generator for writing JSON content using specified output stream. Encoding to use must be specified, and needs to be one of available types (as per JSON specification).
    Underlying stream is NOT owned by the generator constructed, so that generator will NOT close the output stream when JsonGenerator.close() is called (unless auto-closing feature, JsonGenerator.Feature.AUTO_CLOSE_TARGET is enabled). Using application needs to close it explicitly if this is the case.
    Note: there are formats that use fixed encoding (like most binary data formats) and that ignore passed in encoding.
    
    Specified by:
    
    createGenerator in class TokenStreamFactory
    
    Parameters:
    
    out - OutputStream to use for writing JSON content
    
    enc - Character encoding to use
    
    Throws:
    
    IOException
    
    Since:
    
    2.1
  - createGenerator
```
public JsonGenerator createGenerator(OutputStream out)
                              throws IOException
```
    Convenience method for constructing generator that uses default encoding of the format (UTF-8 for JSON and most other data formats).
    Note: there are formats that use fixed encoding (like most binary data formats).
    
    Specified by:
    
    createGenerator in class TokenStreamFactory
    
    Throws:
    
    IOException
    
    Since:
    
    2.1
  - createGenerator
```
public JsonGenerator createGenerator(Writer w)
                              throws IOException
```
    Method for constructing JSON generator for writing JSON content using specified Writer.
    Underlying stream is NOT owned by the generator constructed, so that generator will NOT close the Reader when JsonGenerator.close() is called (unless auto-closing feature, JsonGenerator.Feature.AUTO_CLOSE_TARGET is enabled). Using application needs to close it explicitly.
    
    Specified by:
    
    createGenerator in class TokenStreamFactory
    
    Parameters:
    
    w - Writer to use for writing JSON content
    
    Throws:
    
    IOException
    
    Since:
    
    2.1
  - createGenerator
```
public JsonGenerator createGenerator(File f,
                                     JsonEncoding enc)
                              throws IOException
```
    Method for constructing JSON generator for writing JSON content to specified file, overwriting contents it might have (or creating it if such file does not yet exist). Encoding to use must be specified, and needs to be one of available types (as per JSON specification).
    Underlying stream is owned by the generator constructed, i.e. generator will handle closing of file when JsonGenerator.close() is called.
    
    Specified by:
    
    createGenerator in class TokenStreamFactory
    
    Parameters:
    
    f - File to write contents to
    
    enc - Character encoding to use
    
    Throws:
    
    IOException
    
    Since:
    
    2.1
  - createGenerator
```
public JsonGenerator createGenerator(DataOutput out,
                                     JsonEncoding enc)
                              throws IOException
```
    Method for constructing generator for writing content using specified DataOutput instance.
    
    Specified by:
    
    createGenerator in class TokenStreamFactory
    
    Throws:
    
    IOException
    
    Since:
    
    2.8
  - createGenerator
```
public JsonGenerator createGenerator(DataOutput out)
                              throws IOException
```
    Convenience method for constructing generator that uses default encoding of the format (UTF-8 for JSON and most other data formats).
    Note: there are formats that use fixed encoding (like most binary data formats).
    
    Specified by:
    
    createGenerator in class TokenStreamFactory
    
    Throws:
    
    IOException
    
    Since:
    
    2.8
  - createJsonParser
```
@Deprecated
public JsonParser createJsonParser(File f)
                                        throws IOException,
                                               JsonParseException
```
    Deprecated. Since 2.2, use createParser(File) instead.
    
    Method for constructing JSON parser instance to parse contents of specified file.
    Encoding is auto-detected from contents according to JSON specification recommended mechanism. Json specification supports only UTF-8, UTF-16 and UTF-32 as valid encodings, so auto-detection implemented only for this charsets. For other charsets use createParser(java.io.Reader).
    Underlying input stream (needed for reading contents) will be owned (and managed, i.e. closed as need be) by the parser, since caller has no access to it.
    
    Parameters:
    
    f - File that contains JSON content to parse
    
    Returns:
    
    Parser constructed
    
    Throws:
    
    IOException - if parser initialization fails due to I/O (read) problem
    
    JsonParseException - if parser initialization fails due to content decoding problem
  - createJsonParser
```
@Deprecated
public JsonParser createJsonParser(URL url)
                                        throws IOException,
                                               JsonParseException
```
    Deprecated. Since 2.2, use createParser(URL) instead.
    
    Method for constructing JSON parser instance to parse contents of resource reference by given URL.
    Encoding is auto-detected from contents according to JSON specification recommended mechanism. Json specification supports only UTF-8, UTF-16 and UTF-32 as valid encodings, so auto-detection implemented only for this charsets. For other charsets use createParser(java.io.Reader).
    Underlying input stream (needed for reading contents) will be owned (and managed, i.e. closed as need be) by the parser, since caller has no access to it.
    
    Parameters:
    
    url - URL pointing to resource that contains JSON content to parse
    
    Returns:
    
    Parser constructed
    
    Throws:
    
    IOException - if parser initialization fails due to I/O (read) problem
    
    JsonParseException - if parser initialization fails due to content decoding problem
  - createJsonParser
```
@Deprecated
public JsonParser createJsonParser(InputStream in)
                                        throws IOException,
                                               JsonParseException
```
    Deprecated. Since 2.2, use createParser(InputStream) instead.
    
    Method for constructing JSON parser instance to parse the contents accessed via specified input stream.
    The input stream will not be owned by the parser, it will still be managed (i.e. closed if end-of-stream is reacher, or parser close method called) if (and only if) JsonParser.Feature.AUTO_CLOSE_SOURCE is enabled.
    Note: no encoding argument is taken since it can always be auto-detected as suggested by JSON RFC. Json specification supports only UTF-8, UTF-16 and UTF-32 as valid encodings, so auto-detection implemented only for this charsets. For other charsets use createParser(java.io.Reader).
    
    Parameters:
    
    in - InputStream to use for reading JSON content to parse
    
    Returns:
    
    Parser constructed
    
    Throws:
    
    IOException - if parser initialization fails due to I/O (read) problem
    
    JsonParseException - if parser initialization fails due to content decoding problem
  - createJsonParser
```
@Deprecated
public JsonParser createJsonParser(Reader r)
                                        throws IOException,
                                               JsonParseException
```
    Deprecated. Since 2.2, use createParser(Reader) instead.
    
    Method for constructing parser for parsing the contents accessed via specified Reader.
    The read stream will not be owned by the parser, it will still be managed (i.e. closed if end-of-stream is reacher, or parser close method called) if (and only if) JsonParser.Feature.AUTO_CLOSE_SOURCE is enabled.
    
    Parameters:
    
    r - Reader to use for reading JSON content to parse
    
    Returns:
    
    Parser constructed
    
    Throws:
    
    IOException - if parser initialization fails due to I/O (read) problem
    
    JsonParseException - if parser initialization fails due to content decoding problem
  - createJsonParser
```
@Deprecated
public JsonParser createJsonParser(byte[] data)
                                        throws IOException,
                                               JsonParseException
```
    Deprecated. Since 2.2, use createParser(byte[]) instead.
    
    Method for constructing parser for parsing the contents of given byte array.
    
    Parameters:
    
    data - Input content to parse
    
    Returns:
    
    Parser constructed
    
    Throws:
    
    IOException - if parser initialization fails due to I/O (read) problem
    
    JsonParseException - if parser initialization fails due to content decoding problem
  - createJsonParser
```
@Deprecated
public JsonParser createJsonParser(byte[] data,
                                               int offset,
                                               int len)
                                        throws IOException,
                                               JsonParseException
```
    Deprecated. Since 2.2, use createParser(byte[],int,int) instead.
    
    Method for constructing parser for parsing the contents of given byte array.
    
    Parameters:
    
    data - Buffer that contains data to parse
    
    offset - Offset of the first data byte within buffer
    
    len - Length of contents to parse within buffer
    
    Returns:
    
    Parser constructed
    
    Throws:
    
    IOException - if parser initialization fails due to I/O (read) problem
    
    JsonParseException - if parser initialization fails due to content decoding problem
  - createJsonParser
```
@Deprecated
public JsonParser createJsonParser(String content)
                                        throws IOException,
                                               JsonParseException
```
    Deprecated. Since 2.2, use createParser(String) instead.
    
    Method for constructing parser for parsing contents of given String.
    
    Parameters:
    
    content - Input content to parse
    
    Returns:
    
    Parser constructed
    
    Throws:
    
    IOException - if parser initialization fails due to I/O (read) problem
    
    JsonParseException - if parser initialization fails due to content decoding problem
  - createJsonGenerator
```
@Deprecated
public JsonGenerator createJsonGenerator(OutputStream out,
                                                     JsonEncoding enc)
                                              throws IOException
```
    Deprecated. Since 2.2, use createGenerator(OutputStream, JsonEncoding) instead.
    
    Method for constructing JSON generator for writing JSON content using specified output stream. Encoding to use must be specified, and needs to be one of available types (as per JSON specification).
    Underlying stream is NOT owned by the generator constructed, so that generator will NOT close the output stream when JsonGenerator.close() is called (unless auto-closing feature, JsonGenerator.Feature.AUTO_CLOSE_TARGET is enabled). Using application needs to close it explicitly if this is the case.
    Note: there are formats that use fixed encoding (like most binary data formats) and that ignore passed in encoding.
    
    Parameters:
    
    out - OutputStream to use for writing JSON content
    
    enc - Character encoding to use
    
    Returns:
    
    Generator constructed
    
    Throws:
    
    IOException - if parser initialization fails due to I/O (write) problem
  - createJsonGenerator
```
@Deprecated
public JsonGenerator createJsonGenerator(Writer out)
                                              throws IOException
```
    Deprecated. Since 2.2, use createGenerator(Writer) instead.
    
    Method for constructing JSON generator for writing JSON content using specified Writer.
    Underlying stream is NOT owned by the generator constructed, so that generator will NOT close the Reader when JsonGenerator.close() is called (unless auto-closing feature, JsonGenerator.Feature.AUTO_CLOSE_TARGET is enabled). Using application needs to close it explicitly.
    
    Parameters:
    
    out - Writer to use for writing JSON content
    
    Returns:
    
    Generator constructed
    
    Throws:
    
    IOException - if parser initialization fails due to I/O (write) problem
  - createJsonGenerator
```
@Deprecated
public JsonGenerator createJsonGenerator(OutputStream out)
                                              throws IOException
```
    Deprecated. Since 2.2, use createGenerator(OutputStream) instead.
    
    Convenience method for constructing generator that uses default encoding of the format (UTF-8 for JSON and most other data formats).
    Note: there are formats that use fixed encoding (like most binary data formats).
    
    Parameters:
    
    out - OutputStream to use for writing JSON content
    
    Returns:
    
    Generator constructed
    
    Throws:
    
    IOException - if parser initialization fails due to I/O (write) problem
  - _createParser
```
protected JsonParser _createParser(InputStream in,
                                   IOContext ctxt)
                            throws IOException
```
    Overridable factory method that actually instantiates desired parser given InputStream and context object.
    This method is specifically designed to remain compatible between minor versions so that sub-classes can count on it being called as expected. That is, it is part of official interface from sub-class perspective, although not a public method available to users of factory implementations.
    
    Parameters:
    
    in - InputStream to use for reading content to parse
    
    ctxt - I/O context to use for parsing
    
    Returns:
    
    Parser constructed
    
    Throws:
    
    IOException - if parser initialization fails due to I/O (read) problem
    
    Since:
    
    2.1
  - _createParser
```
protected JsonParser _createParser(Reader r,
                                   IOContext ctxt)
                            throws IOException
```
    Overridable factory method that actually instantiates parser using given Reader object for reading content.
    This method is specifically designed to remain compatible between minor versions so that sub-classes can count on it being called as expected. That is, it is part of official interface from sub-class perspective, although not a public method available to users of factory implementations.
    
    Parameters:
    
    r - Reader to use for reading content to parse
    
    ctxt - I/O context to use for parsing
    
    Returns:
    
    Actual parser to use
    
    Throws:
    
    IOException - if parser initialization fails due to I/O (read) problem
    
    Since:
    
    2.1
  - _createParser
```
protected JsonParser _createParser(char[] data,
                                   int offset,
                                   int len,
                                   IOContext ctxt,
                                   boolean recyclable)
                            throws IOException
```
    Overridable factory method that actually instantiates parser using given char[] object for accessing content.
    
    Parameters:
    
    data - Buffer that contains content to parse
    
    offset - Offset to the first character of data to parse
    
    len - Number of characters within buffer to parse
    
    ctxt - I/O context to use for parsing
    
    recyclable - Whether input buffer is recycled by the factory
    
    Returns:
    
    Actual parser to use
    
    Throws:
    
    IOException - if parser initialization fails due to I/O (read) problem
    
    Since:
    
    2.4
  - _createParser
```
protected JsonParser _createParser(byte[] data,
                                   int offset,
                                   int len,
                                   IOContext ctxt)
                            throws IOException
```
    Overridable factory method that actually instantiates parser using given Reader object for reading content passed as raw byte array.
    This method is specifically designed to remain compatible between minor versions so that sub-classes can count on it being called as expected. That is, it is part of official interface from sub-class perspective, although not a public method available to users of factory implementations.
    
    Parameters:
    
    data - Buffer that contains content to parse
    
    offset - Offset to the first character of data to parse
    
    len - Number of characters within buffer to parse
    
    ctxt - I/O context to use for parsing
    
    Returns:
    
    Actual parser to use
    
    Throws:
    
    IOException - if parser initialization fails due to I/O (read) problem
  - _createParser
```
protected JsonParser _createParser(DataInput input,
                                   IOContext ctxt)
                            throws IOException
```
    Optional factory method, expected to be overridden
    
    Parameters:
    
    input - DataInput to use for reading content to parse
    
    ctxt - I/O context to use for parsing
    
    Returns:
    
    Actual parser to use
    
    Throws:
    
    IOException - if parser initialization fails due to I/O (read) problem
    
    Since:
    
    2.8
  - _createGenerator
```
protected JsonGenerator _createGenerator(Writer out,
                                         IOContext ctxt)
                                  throws IOException
```
    Overridable factory method that actually instantiates generator for given Writer and context object.
    This method is specifically designed to remain compatible between minor versions so that sub-classes can count on it being called as expected. That is, it is part of official interface from sub-class perspective, although not a public method available to users of factory implementations.
    
    Parameters:
    
    out - Writer underlying writer to write generated content to
    
    ctxt - I/O context to use
    
    Returns:
    
    This factory instance (to allow call chaining)
    
    Throws:
    
    IOException - if parser initialization fails due to I/O (write) problem
  - _createUTF8Generator
```
protected JsonGenerator _createUTF8Generator(OutputStream out,
                                             IOContext ctxt)
                                      throws IOException
```
    Overridable factory method that actually instantiates generator for given OutputStream and context object, using UTF-8 encoding.
    This method is specifically designed to remain compatible between minor versions so that sub-classes can count on it being called as expected. That is, it is part of official interface from sub-class perspective, although not a public method available to users of factory implementations.
    
    Parameters:
    
    out - OutputStream underlying writer to write generated content to
    
    ctxt - I/O context to use
    
    Returns:
    
    This factory instance (to allow call chaining)
    
    Throws:
    
    IOException - if parser initialization fails due to I/O (write) problem
  - _createWriter
```
protected Writer _createWriter(OutputStream out,
                               JsonEncoding enc,
                               IOContext ctxt)
                        throws IOException
```
    Throws:
    
    IOException
  - _decorate
```
protected final InputStream _decorate(InputStream in,
                                      IOContext ctxt)
                               throws IOException
```
    Throws:
    
    IOException
  - _decorate
```
protected final Reader _decorate(Reader in,
                                 IOContext ctxt)
                          throws IOException
```
    Throws:
    
    IOException
  - _decorate
```
protected final DataInput _decorate(DataInput in,
                                    IOContext ctxt)
                             throws IOException
```
    Throws:
    
    IOException
  - _decorate
```
protected final OutputStream _decorate(OutputStream out,
                                       IOContext ctxt)
                                throws IOException
```
    Throws:
    
    IOException
  - _decorate
```
protected final Writer _decorate(Writer out,
                                 IOContext ctxt)
                          throws IOException
```
    Throws:
    
    IOException
  - _getBufferRecycler
```
public BufferRecycler _getBufferRecycler()
```
    Method used by factory to create buffer recycler instances for parsers and generators.
    Note: only public to give access for ObjectMapper
    
    Returns:
    
    Buffer recycler instance to use
  - _createContext
```
protected IOContext _createContext(ContentReference contentRef,
                                   boolean resourceManaged)
```
    Overridable factory method that actually instantiates desired context object.
    
    Parameters:
    
    contentRef - Source/target reference to use for diagnostics, exception messages
    
    resourceManaged - Whether input/output buffer is managed by this factory or not
    
    Returns:
    
    I/O context created
  - _createContext
```
@Deprecated
protected IOContext _createContext(Object rawContentRef,
                                               boolean resourceManaged)
```
    Deprecated. Since 2.13
    
    Deprecated variant of _createContext(Object, boolean)
    
    Parameters:
    
    rawContentRef - "Raw" source/target reference
    
    resourceManaged - Whether input/output buffer is managed by this factory or not
    
    Returns:
    
    I/O context created
  - _createNonBlockingContext
```
protected IOContext _createNonBlockingContext(Object srcRef)
```
    Overridable factory method that actually instantiates desired context object for async (non-blocking) parsing
    
    Parameters:
    
    srcRef - Source reference to use for diagnostics, exception messages
    
    Returns:
    
    I/O context created
    
    Since:
    
    2.9.7
  - _createContentReference
```
protected ContentReference _createContentReference(Object contentAccessor)
```
    Overridable factory method for constructing ContentReference to pass to parser or generator being created; used in cases where no offset or length is applicable (either irrelevant, or full contents assumed).
    
    Parameters:
    
    contentAccessor - Access to underlying content; depends on source/target, as well as content representation
    
    Returns:
    
    Reference instance to use
    
    Since:
    
    2.13
  - _createContentReference
```
protected ContentReference _createContentReference(Object contentAccessor,
                                                   int offset,
                                                   int length)
```
    Overridable factory method for constructing ContentReference to pass to parser or generator being created; used in cases where content is available in a static buffer with relevant offset and length (mostly when reading from byte[], char[] or String).
    
    Parameters:
    
    contentAccessor - Access to underlying content; depends on source/target, as well as content representation
    
    offset - Offset of content
    
    length - Length of content
    
    Returns:
    
    Reference instance to use
    
    Since:
    
    2.13

Class JsonFactory

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class com.fasterxml.jackson.core.TokenStreamFactory

Methods inherited from class java.lang.Object

Field Detail

FORMAT_NAME_JSON

DEFAULT_FACTORY_FEATURE_FLAGS

DEFAULT_PARSER_FEATURE_FLAGS

DEFAULT_GENERATOR_FEATURE_FLAGS

DEFAULT_ROOT_VALUE_SEPARATOR

DEFAULT_QUOTE_CHAR

_rootCharSymbols

_byteSymbolCanonicalizer

_factoryFeatures

_parserFeatures

_generatorFeatures

_objectCodec

_characterEscapes

_inputDecorator

_outputDecorator

_rootValueSeparator

_maximumNonEscapedChar

_quoteChar

Constructor Detail

JsonFactory

JsonFactory

JsonFactory

JsonFactory

JsonFactory

Method Detail

rebuild

builder

copy

_checkInvalidCopy

readResolve

requiresPropertyOrdering

canHandleBinaryNatively

canUseCharArrays

canParseAsync

getFormatReadFeatureType

getFormatWriteFeatureType

canUseSchema

getFormatName

hasFormat

requiresCustomCodec

hasJSONFormat

version

configure

enable

disable

isEnabled

getParserFeatures

getGeneratorFeatures

getFormatParserFeatures

getFormatGeneratorFeatures

configure

enable

disable

isEnabled

isEnabled

getInputDecorator

setInputDecorator

configure

enable

disable

isEnabled

isEnabled

getCharacterEscapes

setCharacterEscapes

getOutputDecorator

setOutputDecorator

setRootValueSeparator

getRootValueSeparator

setCodec

getCodec

createParser

createParser