JsonParser (Jodd API Documentation)

java.lang.Object
- jodd.json.JsonParserBase
- - jodd.json.JsonParser

```
public class JsonParser
extends JsonParserBase
```
Simple, developer-friendly JSON parser. It focuses on easy usage and type mappings. Uses Jodd's type converters, so it is natural companion for Jodd projects.
This JSON parser also works in lazy(boolean) mode. This mode is for top performance usage: parsing is done very, very lazy. While you can use all the mappings and other tools, for best performance the lazy mode should be used only with maps and lists (no special mappings). Also, the performance has it's price: more memory consumption, because the original input is hold until the result is in use.
See: http://www.ietf.org/rfc/rfc4627.txt

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class JsonParser.Defaults

Nested Classes
Modifier and Type	Class and Description
`static class`	`JsonParser.Defaults`

Field Summary

Fields
Modifier and Type	Field and Description
`protected java.lang.String`	`classMetadataName`
`protected java.util.Map<Path,ValueConverter>`	`convs`
`protected char[]`	`input`
`static java.lang.String`	`KEYS` Map keys.
`protected boolean`	`lazy`
`protected boolean`	`looseMode`
`protected java.util.Map<Path,java.lang.Class>`	`mappings`
`protected MapToBean`	`mapToBean`
`protected int`	`ndx`
`protected Path`	`path`
`protected java.lang.Class`	`rootType`
`protected char[]`	`text`
`protected int`	`textLen`
`protected int`	`total`
`protected boolean`	`useAltPaths`
`static java.lang.String`	`VALUES` Array or map values.

Fields inherited from class jodd.json.JsonParserBase
ARRAYLIST_SUPPLIER, classnameWhitelist, HASHMAP_SUPPLIER, LAZYLIST_SUPPLIER, LAZYMAP_SUPPLIER, listSupplier, mapSupplier, strictTypes

Constructor Summary

Constructors
Constructor and Description

JsonParser()

Constructors
Constructor and Description
`JsonParser()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`JsonParser`	`allowAllClasses()` Removes the whitelist of allowed classes.
`JsonParser`	`allowClass(java.lang.String classPattern)` Adds a `wildcard` pattern for white-listing classes.
`protected void`	`consume(char c)` Consumes char at current position.
`protected char`	`consumeOneOf(char c1, char c2)` Consumes one of the allowed char at current position.
`static JsonParser`	`create()` Static ctor.
`static JsonParser`	`createLazyOne()` Creates a lazy implementation of the JSON parser.
`protected void`	`growAndCopy()` Grows text array when `text.length == textLen`.
`protected void`	`growEmpty()` Grows empty text array.
`protected boolean`	`isEOF()` Returns `true` if scanning is at the end.
`JsonParser`	`lazy(boolean lazy)` Defines how JSON parser works.
`protected ValueConverter`	`lookupValueConverter()` Lookups for value converter for current path.
`JsonParser`	`looseMode(boolean looseMode)` Enables 'loose' mode for parsing.
`JsonParser`	`map(java.lang.Class target)` Maps a class to JSONs root.
`JsonParser`	`map(java.lang.String path, java.lang.Class target)` Maps a class to given path.
`protected boolean`	`match(char[] target)` Matches char buffer with content on given location.
`<T> T`	`parse(char[] input)` Parses input JSON char array.
`<T> T`	`parse(char[] input, java.lang.Class<T> targetType)` Parses input JSON as given type.
`<T> T`	`parse(java.lang.String input)` Parses input JSON string.
`<T> T`	`parse(java.lang.String input, java.lang.Class<T> targetType)` Parses input JSON as given type.
`protected java.lang.Object`	`parseArrayContent(java.lang.Class targetType, java.lang.Class componentType)` Parses arrays, once when open bracket has been consumed.
`JsonArray`	`parseAsJsonArray(java.lang.String input)` Parses input JSON to `JsonArray`, special case of parsing.
`JsonObject`	`parseAsJsonObject(java.lang.String input)` Parses input JSON to `JsonObject`, special case of `parse(String, Class)`.
`<T> java.util.List<T>`	`parseAsList(java.lang.String string, java.lang.Class<T> componentType)` Parses input JSON to a list with specified component type.
`<K,V> java.util.Map<K,V>`	`parseAsMap(java.lang.String string, java.lang.Class<K> keyType, java.lang.Class<V> valueType)` Parses input JSON to a list with specified key and value types.
`protected java.lang.Number`	`parseNumber()` Parses JSON numbers.
`protected java.lang.Object`	`parseObjectContent(java.lang.Class targetType, java.lang.Class valueKeyType, java.lang.Class valueType)` Parses object, once when open bracket has been consumed.
`protected java.lang.String`	`parseString()` Parses a string.
`protected java.lang.String`	`parseStringContent(char quote)` Parses string content, once when starting quote has been consumed.
`protected char`	`parseUnicode()` Parses 4 characters and returns unicode character.
`protected java.lang.String`	`parseUnquotedStringContent()` Parses un-quoted string content.
`protected java.lang.Object`	`parseValue(java.lang.Class targetType, java.lang.Class keyType, java.lang.Class componentType)` Parses a JSON value.
`protected java.lang.Class`	`replaceWithMappedTypeForPath(java.lang.Class target)` Replaces type with mapped type for current path.
`protected void`	`reset()` Resets JSON parser, so it can be reused.
`JsonParser`	`setClassMetadataName(java.lang.String name)` Sets local class meta-data name.
`protected void`	`skipWhiteSpaces()` Skips whitespaces.
`JsonParser`	`strictTypes(boolean strictTypes)` Defines if type conversion is strict.
`protected void`	`syntaxError(java.lang.String message)` Throws `JsonException` indicating a syntax error.
`JsonParser`	`useAltPaths()` Enables usage of additional paths.
`JsonParser`	`withClassMetadata(boolean useMetadata)` Sets usage of default class meta-data name.
`JsonParser`	`withValueConverter(java.lang.String path, ValueConverter valueConverter)` Defines `ValueConverter` to use on given path.

Methods inherited from class jodd.json.JsonParserBase
convertType, createMapToBean, injectValueIntoObject, newArrayInstance, newObjectInstance

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

- Field Detail
  - KEYS
```
public static final java.lang.String KEYS
```
    Map keys.
    
    See Also:
    
    Constant Field Values
  - VALUES
```
public static final java.lang.String VALUES
```
    Array or map values.
    
    See Also:
    
    Constant Field Values
  - ndx
```
protected int ndx
```
  - input
```
protected char[] input
```
  - total
```
protected int total
```
  - path
```
protected Path path
```
  - useAltPaths
```
protected boolean useAltPaths
```
  - lazy
```
protected boolean lazy
```
  - looseMode
```
protected boolean looseMode
```
  - rootType
```
protected java.lang.Class rootType
```
  - mapToBean
```
protected MapToBean mapToBean
```
  - mappings
```
protected java.util.Map<Path,java.lang.Class> mappings
```
  - convs
```
protected java.util.Map<Path,ValueConverter> convs
```
  - classMetadataName
```
protected java.lang.String classMetadataName
```
  - text
```
protected char[] text
```
  - textLen
```
protected int textLen
```
- Constructor Detail
  - JsonParser
```
public JsonParser()
```
- Method Detail
  - create
```
public static JsonParser create()
```
    Static ctor.
  - createLazyOne
```
public static JsonParser createLazyOne()
```
    Creates a lazy implementation of the JSON parser.
  - reset
```
protected void reset()
```
    Resets JSON parser, so it can be reused.
  - useAltPaths
```
public JsonParser useAltPaths()
```
    Enables usage of additional paths.
  - looseMode
```
public JsonParser looseMode(boolean looseMode)
```
    Enables 'loose' mode for parsing. When 'loose' mode is enabled, JSON parsers swallows also invalid JSONs:
    - invalid escape character sequence is simply added to the output
    - strings can be quoted with single-quotes
    - strings can be unquoted, but may not contain escapes
  - strictTypes
```
public JsonParser strictTypes(boolean strictTypes)
```
    Defines if type conversion is strict. If not, all exceptions will be caught and replaced with null.
  - lazy
```
public JsonParser lazy(boolean lazy)
```
    Defines how JSON parser works. In non-lazy mode, the whole JSON is parsed as it is. In the lazy mode, not everything is parsed, but some things are left lazy. This way we gain performance, especially on partial usage of the whole JSON. However, be aware that parser holds the input memory until the returned objects are disposed.
  - map
```
public JsonParser map(java.lang.Class target)
```
    Maps a class to JSONs root.
  - map
```
public JsonParser map(java.lang.String path,
                      java.lang.Class target)
```
    Maps a class to given path. For arrays, append values to the path to specify component type (if not specified by generics).
  - replaceWithMappedTypeForPath
```
protected java.lang.Class replaceWithMappedTypeForPath(java.lang.Class target)
```
    Replaces type with mapped type for current path.
  - withValueConverter
```
public JsonParser withValueConverter(java.lang.String path,
                                     ValueConverter valueConverter)
```
    Defines ValueConverter to use on given path.
  - lookupValueConverter
```
protected ValueConverter lookupValueConverter()
```
    Lookups for value converter for current path.
  - setClassMetadataName
```
public JsonParser setClassMetadataName(java.lang.String name)
```
    Sets local class meta-data name.
    Note that by using the class meta-data name you may expose a security hole in case untrusted source manages to specify a class that is accessible through class loader and exposes set of methods and/or fields, access of which opens an actual security hole. Such classes are known as “deserialization gadget”s. Because of this, use of "default typing" is not encouraged in general, and in particular is recommended against if the source of content is not trusted. Conversely, default typing may be used for processing content in cases where both ends (sender and receiver) are controlled by same entity.
  - withClassMetadata
```
public JsonParser withClassMetadata(boolean useMetadata)
```
    Sets usage of default class meta-data name. Using it may introduce a security hole, see setClassMetadataName(String) for more details.
    
    See Also:
    
    setClassMetadataName(String)
  - allowClass
```
public JsonParser allowClass(java.lang.String classPattern)
```
    Adds a wildcard pattern for white-listing classes.
    
    See Also:
    
    setClassMetadataName(String)
  - allowAllClasses
```
public JsonParser allowAllClasses()
```
    Removes the whitelist of allowed classes.
    
    See Also:
    
    setClassMetadataName(String)
  - parse
```
public <T> T parse(java.lang.String input,
                   java.lang.Class<T> targetType)
```
    Parses input JSON as given type.
  - parseAsJsonObject
```
public JsonObject parseAsJsonObject(java.lang.String input)
```
    Parses input JSON to JsonObject, special case of parse(String, Class).
  - parseAsJsonArray
```
public JsonArray parseAsJsonArray(java.lang.String input)
```
    Parses input JSON to JsonArray, special case of parsing.
  - parseAsList
```
public <T> java.util.List<T> parseAsList(java.lang.String string,
                                         java.lang.Class<T> componentType)
```
    Parses input JSON to a list with specified component type.
  - parseAsMap
```
public <K,V> java.util.Map<K,V> parseAsMap(java.lang.String string,
                                           java.lang.Class<K> keyType,
                                           java.lang.Class<V> valueType)
```
    Parses input JSON to a list with specified key and value types.
  - parse
```
public <T> T parse(java.lang.String input)
```
    Parses input JSON string.
  - parse
```
public <T> T parse(char[] input,
                   java.lang.Class<T> targetType)
```
    Parses input JSON as given type.
  - parse
```
public <T> T parse(char[] input)
```
    Parses input JSON char array.
  - parseValue
```
protected java.lang.Object parseValue(java.lang.Class targetType,
                                      java.lang.Class keyType,
                                      java.lang.Class componentType)
```
    Parses a JSON value.
    
    Parameters:
    
    targetType - target type to convert, may be null
    
    componentType - component type for maps and arrays, may be null
  - parseString
```
protected java.lang.String parseString()
```
    Parses a string.
  - parseStringContent
```
protected java.lang.String parseStringContent(char quote)
```
    Parses string content, once when starting quote has been consumed.
  - growEmpty
```
protected void growEmpty()
```
    Grows empty text array.
  - growAndCopy
```
protected void growAndCopy()
```
    Grows text array when text.length == textLen.
  - parseUnicode
```
protected char parseUnicode()
```
    Parses 4 characters and returns unicode character.
  - parseUnquotedStringContent
```
protected java.lang.String parseUnquotedStringContent()
```
    Parses un-quoted string content.
  - parseNumber
```
protected java.lang.Number parseNumber()
```
    Parses JSON numbers.
  - parseArrayContent
```
protected java.lang.Object parseArrayContent(java.lang.Class targetType,
                                             java.lang.Class componentType)
```
    Parses arrays, once when open bracket has been consumed.
  - parseObjectContent
```
protected java.lang.Object parseObjectContent(java.lang.Class targetType,
                                              java.lang.Class valueKeyType,
                                              java.lang.Class valueType)
```
    Parses object, once when open bracket has been consumed.
  - consume
```
protected void consume(char c)
```
    Consumes char at current position. If char is different, throws the exception.
  - consumeOneOf
```
protected char consumeOneOf(char c1,
                            char c2)
```
    Consumes one of the allowed char at current position. If char is different, return 0. If matched, returns matched char.
  - isEOF
```
protected boolean isEOF()
```
    Returns true if scanning is at the end.
  - skipWhiteSpaces
```
protected final void skipWhiteSpaces()
```
    Skips whitespaces. For the simplification, whitespaces are considered any characters less or equal to 32 (space).
  - match
```
protected final boolean match(char[] target)
```
    Matches char buffer with content on given location.
  - syntaxError
```
protected void syntaxError(java.lang.String message)
```
    Throws JsonException indicating a syntax error.

Class JsonParser

Nested Class Summary

Field Summary

Fields inherited from class jodd.json.JsonParserBase

Constructor Summary

Method Summary

Methods inherited from class jodd.json.JsonParserBase

Methods inherited from class java.lang.Object

Field Detail

KEYS

VALUES

ndx

input

total

path

useAltPaths

lazy

looseMode

rootType

mapToBean

mappings

convs

classMetadataName

text

textLen

Constructor Detail

JsonParser

Method Detail

create

createLazyOne

reset

useAltPaths

looseMode

strictTypes

lazy

map

map

replaceWithMappedTypeForPath

withValueConverter

lookupValueConverter

setClassMetadataName

withClassMetadata

allowClass

allowAllClasses

parse

parseAsJsonObject

parseAsJsonArray

parseAsList

parseAsMap

parse

parse

parse

parseValue

parseString

parseStringContent

growEmpty

growAndCopy

parseUnicode

parseUnquotedStringContent

parseNumber

parseArrayContent

parseObjectContent

consume

consumeOneOf

isEOF

skipWhiteSpaces

match

syntaxError