## Uses of Class
com.fasterxml.jackson.core.JsonParseException

Packages that use JsonParseException
com.fasterxml.jackson.core: Main public API classes of the core streaming JSON processor: most importantly `JsonFactory` used for constructing JSON parser (`JsonParser`) and generator (`JsonParser`) instances.
com.fasterxml.jackson.core.base: Base classes used by concrete Parser and Generator implementations; contain functionality that is not specific to JSON or input abstraction (byte vs char).
com.fasterxml.jackson.core.json: JSON-specific parser and generator implementation classes that Jackson defines and uses.
com.fasterxml.jackson.core.util: Utility classes used by Jackson Core functionality.

Uses of JsonParseException in com.fasterxml.jackson.core

Methods in com.fasterxml.jackson.core that return JsonParseException
`protected JsonParseException` `JsonParser._constructError(String msg)` Helper method for constructing `JsonParseException`s based on current state of the parser

Methods in com.fasterxml.jackson.core that throw JsonParseException
`protected JsonParser` `JsonFactory._createJsonParser(byte[] data, int offset, int len, IOContext ctxt)` Deprecated. since 2.1 -- use `JsonFactory._createParser(byte[], int, int, IOContext)` instead
`protected JsonParser` `JsonFactory._createJsonParser(InputStream in, IOContext ctxt)` Deprecated. since 2.1 -- use `JsonFactory._createParser(InputStream, IOContext)` instead
`protected JsonParser` `JsonFactory._createJsonParser(Reader r, IOContext ctxt)` Deprecated. since 2.1 -- use `JsonFactory._createParser(Reader, IOContext)` instead
`protected JsonParser` `JsonFactory._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` `JsonFactory._createParser(InputStream in, IOContext ctxt)` Overridable factory method that actually instantiates desired parser given `InputStream` and context object.
`protected JsonParser` `JsonFactory._createParser(Reader r, IOContext ctxt)` Overridable factory method that actually instantiates parser using given `Reader` object for reading content.
`JsonParser` `JsonFactory.createJsonParser(byte[] data)` Method for constructing parser for parsing the contents of given byte array.
`JsonParser` `JsonFactory.createJsonParser(byte[] data, int offset, int len)` Method for constructing parser for parsing the contents of given byte array.
`JsonParser` `JsonFactory.createJsonParser(File f)` Method for constructing JSON parser instance to parse contents of specified file.
`JsonParser` `JsonFactory.createJsonParser(InputStream in)` Method for constructing JSON parser instance to parse the contents accessed via specified input stream.
`JsonParser` `JsonFactory.createJsonParser(Reader r)` Method for constructing parser for parsing the contents accessed via specified Reader.
`JsonParser` `JsonFactory.createJsonParser(String content)` Method for constructing parser for parsing contents of given String.
`JsonParser` `JsonFactory.createJsonParser(URL url)` Method for constructing JSON parser instance to parse contents of resource reference by given URL.
`JsonParser` `JsonFactory.createParser(byte[] data)` Method for constructing parser for parsing the contents of given byte array.
`JsonParser` `JsonFactory.createParser(byte[] data, int offset, int len)` Method for constructing parser for parsing the contents of given byte array.
`JsonParser` `JsonFactory.createParser(File f)` Method for constructing JSON parser instance to parse contents of specified file.
`JsonParser` `JsonFactory.createParser(InputStream in)` Method for constructing JSON parser instance to parse the contents accessed via specified input stream.
`JsonParser` `JsonFactory.createParser(Reader r)` Method for constructing parser for parsing the contents accessed via specified Reader.
`JsonParser` `JsonFactory.createParser(String content)` Method for constructing parser for parsing contents of given String.
`JsonParser` `JsonFactory.createParser(URL url)` Method for constructing JSON parser instance to parse contents of resource reference by given URL.
`abstract BigInteger` `JsonParser.getBigIntegerValue()` Numeric accessor that can be called when the current token is of type `JsonToken.VALUE_NUMBER_INT` and it can not be used as a Java long primitive type due to its magnitude.
`byte[]` `JsonParser.getBinaryValue()` Convenience alternative to `JsonParser.getBinaryValue(Base64Variant)` that defaults to using `Base64Variants.getDefaultVariant()` as the default encoding.
`abstract byte[]` `JsonParser.getBinaryValue(Base64Variant b64variant)` Method that can be used to read (and consume -- results may not be accessible using other methods after the call) base64-encoded binary data included in the current textual JSON value.
`boolean` `JsonParser.getBooleanValue()` Convenience accessor that can be called when the current token is `JsonToken.VALUE_TRUE` or `JsonToken.VALUE_FALSE`.
`byte` `JsonParser.getByteValue()` Numeric accessor that can be called when the current token is of type `JsonToken.VALUE_NUMBER_INT` and it can be expressed as a value of Java byte primitive type.
`abstract String` `JsonParser.getCurrentName()` Method that can be called to get the name associated with the current token: for `JsonToken.FIELD_NAME`s it will be the same as what `JsonParser.getText()` returns; for field values it will be preceding field name; and for others (array values, root-level values) null.
`abstract BigDecimal` `JsonParser.getDecimalValue()` Numeric accessor that can be called when the current token is of type `JsonToken.VALUE_NUMBER_FLOAT` or `JsonToken.VALUE_NUMBER_INT`.
`abstract double` `JsonParser.getDoubleValue()` Numeric accessor that can be called when the current token is of type `JsonToken.VALUE_NUMBER_FLOAT` and it can be expressed as a Java double primitive type.
`abstract Object` `JsonParser.getEmbeddedObject()` Accessor that can be called if (and only if) the current token is `JsonToken.VALUE_EMBEDDED_OBJECT`.
`abstract float` `JsonParser.getFloatValue()` Numeric accessor that can be called when the current token is of type `JsonToken.VALUE_NUMBER_FLOAT` and it can be expressed as a Java float primitive type.
`abstract int` `JsonParser.getIntValue()` Numeric accessor that can be called when the current token is of type `JsonToken.VALUE_NUMBER_INT` and it can be expressed as a value of Java int primitive type.
`abstract long` `JsonParser.getLongValue()` Numeric accessor that can be called when the current token is of type `JsonToken.VALUE_NUMBER_INT` and it can be expressed as a Java long primitive type.
`abstract JsonParser.NumberType` `JsonParser.getNumberType()` If current token is of type `JsonToken.VALUE_NUMBER_INT` or `JsonToken.VALUE_NUMBER_FLOAT`, returns one of `JsonParser.NumberType` constants; otherwise returns null.
`abstract Number` `JsonParser.getNumberValue()` Generic number value accessor method that will work for all kinds of numeric values.
`short` `JsonParser.getShortValue()` Numeric accessor that can be called when the current token is of type `JsonToken.VALUE_NUMBER_INT` and it can be expressed as a value of Java short primitive type.
`abstract String` `JsonParser.getText()` Method for accessing textual representation of the current token; if no current token (before first call to `JsonParser.nextToken()`, or after encountering end-of-input), returns null.
`abstract char[]` `JsonParser.getTextCharacters()` Method similar to `JsonParser.getText()`, but that will return underlying (unmodifiable) character array that contains textual value, instead of constructing a String object to contain this information.
`abstract int` `JsonParser.getTextLength()` Accessor used with `JsonParser.getTextCharacters()`, to know length of String stored in returned buffer.
`abstract int` `JsonParser.getTextOffset()` Accessor used with `JsonParser.getTextCharacters()`, to know offset of the first text content character within buffer.
`boolean` `JsonParser.getValueAsBoolean()` Method that will try to convert value of current token to a boolean.
`boolean` `JsonParser.getValueAsBoolean(boolean defaultValue)` Method that will try to convert value of current token to a boolean.
`double` `JsonParser.getValueAsDouble()` Method that will try to convert value of current token to a Java double.
`double` `JsonParser.getValueAsDouble(double defaultValue)` Method that will try to convert value of current token to a Java double.
`int` `JsonParser.getValueAsInt()` Method that will try to convert value of current token to a int.
`int` `JsonParser.getValueAsInt(int defaultValue)` Method that will try to convert value of current token to a int.
`long` `JsonParser.getValueAsLong()` Method that will try to convert value of current token to a long.
`long` `JsonParser.getValueAsLong(long defaultValue)` Method that will try to convert value of current token to a long.
`String` `JsonParser.getValueAsString()` Method that will try to convert value of current token to a `String`.
`abstract String` `JsonParser.getValueAsString(String defaultValue)` Method that will try to convert value of current token to a `String`.
`Boolean` `JsonParser.nextBooleanValue()` Method that fetches next token (as if calling `JsonParser.nextToken()`) and if it is `JsonToken.VALUE_TRUE` or `JsonToken.VALUE_FALSE` returns matching Boolean value; otherwise return null.
`boolean` `JsonParser.nextFieldName(SerializableString str)` Method that fetches next token (as if calling `JsonParser.nextToken()`) and verifies whether it is `JsonToken.FIELD_NAME` with specified name and returns result of that comparison.
`int` `JsonParser.nextIntValue(int defaultValue)` Method that fetches next token (as if calling `JsonParser.nextToken()`) and if it is `JsonToken.VALUE_NUMBER_INT` returns 32-bit int value; otherwise returns specified default value It is functionally equivalent to:
`long` `JsonParser.nextLongValue(long defaultValue)` Method that fetches next token (as if calling `JsonParser.nextToken()`) and if it is `JsonToken.VALUE_NUMBER_INT` returns 64-bit long value; otherwise returns specified default value It is functionally equivalent to:
`String` `JsonParser.nextTextValue()` Method that fetches next token (as if calling `JsonParser.nextToken()`) and if it is `JsonToken.VALUE_STRING` returns contained String value; otherwise returns null.
`abstract JsonToken` `JsonParser.nextToken()` Main iteration method, which will advance stream enough to determine type of the next token, if any.
`abstract JsonToken` `JsonParser.nextValue()` Iteration method that will advance stream enough to determine type of the next token that is a value type (including JSON Array and Object start/end markers).
`int` `JsonParser.readBinaryValue(Base64Variant b64variant, OutputStream out)` Similar to `JsonParser.readBinaryValue(OutputStream)` but allows explicitly specifying base64 variant to use.
`int` `JsonParser.readBinaryValue(OutputStream out)` Method that can be used as an alternative to `JsonParser.getBigIntegerValue()`, especially when value can be large.
`abstract JsonParser` `JsonParser.skipChildren()` Method that will skip all child tokens of an array or object token that the parser currently points to, iff stream points to `JsonToken.START_OBJECT` or `JsonToken.START_ARRAY`.

Uses of JsonParseException in com.fasterxml.jackson.core.base

Methods in com.fasterxml.jackson.core.base that return JsonParseException
`protected JsonParseException` `ParserMinimalBase._constructError(String msg, Throwable t)`

Methods in com.fasterxml.jackson.core.base that throw JsonParseException
`protected void` `ParserMinimalBase._decodeBase64(String str, ByteArrayBuilder builder, Base64Variant b64variant)` Helper method that can be used for base64 decoding in cases where encoded content has already been read as a String.
`protected int` `ParserBase._decodeBase64Escape(Base64Variant b64variant, char ch, int index)`
`protected int` `ParserBase._decodeBase64Escape(Base64Variant b64variant, int ch, int index)`
`protected char` `ParserBase._decodeEscaped()` Method that sub-classes must implement to support escaped sequences in base64-encoded sections.
`protected abstract void` `ParserBase._finishString()`
`protected abstract void` `ParserMinimalBase._handleEOF()` Method sub-classes need to implement
`protected void` `ParserBase._handleEOF()` Method called when an EOF is encountered between tokens.
`protected void` `ParserBase._parseNumericValue(int expType)` Method that will parse actual numeric value out of a syntactically valid number value.
`protected void` `ParserMinimalBase._reportBase64EOF()`
`protected void` `ParserMinimalBase._reportError(String msg)`
`protected void` `ParserMinimalBase._reportInvalidBase64(Base64Variant b64variant, char ch, int bindex, String msg)`
`protected void` `ParserMinimalBase._reportInvalidEOF()`
`protected void` `ParserMinimalBase._reportInvalidEOF(String msg)`
`protected void` `ParserMinimalBase._reportInvalidEOFInValue()`
`protected void` `ParserBase._reportMismatchedEndMarker(int actCh, char expCh)`
`protected void` `ParserMinimalBase._reportUnexpectedChar(int ch, String comment)`
`protected void` `ParserMinimalBase._throwInvalidSpace(int i)`
`protected void` `ParserMinimalBase._throwUnquotedSpace(int i, String ctxtDesc)` Method called to report a problem with unquoted control character.
`protected void` `ParserMinimalBase._wrapError(String msg, Throwable t)`
`protected void` `ParserBase.convertNumberToBigDecimal()`
`protected void` `ParserBase.convertNumberToBigInteger()`
`protected void` `ParserBase.convertNumberToDouble()`
`protected void` `ParserBase.convertNumberToInt()`
`protected void` `ParserBase.convertNumberToLong()`
`BigInteger` `ParserBase.getBigIntegerValue()`
`abstract byte[]` `ParserMinimalBase.getBinaryValue(Base64Variant b64variant)`
`abstract String` `ParserMinimalBase.getCurrentName()`
`String` `ParserBase.getCurrentName()` Method that can be called to get the name associated with the current event.
`BigDecimal` `ParserBase.getDecimalValue()`
`double` `ParserBase.getDoubleValue()`
`float` `ParserBase.getFloatValue()`
`int` `ParserBase.getIntValue()`
`long` `ParserBase.getLongValue()`
`JsonParser.NumberType` `ParserBase.getNumberType()`
`Number` `ParserBase.getNumberValue()`
`abstract String` `ParserMinimalBase.getText()`
`abstract char[]` `ParserMinimalBase.getTextCharacters()`
`abstract int` `ParserMinimalBase.getTextLength()`
`abstract int` `ParserMinimalBase.getTextOffset()`
`boolean` `ParserMinimalBase.getValueAsBoolean(boolean defaultValue)`
`double` `ParserMinimalBase.getValueAsDouble(double defaultValue)`
`int` `ParserMinimalBase.getValueAsInt(int defaultValue)`
`long` `ParserMinimalBase.getValueAsLong(long defaultValue)`
`String` `ParserMinimalBase.getValueAsString(String defaultValue)`
`abstract JsonToken` `ParserMinimalBase.nextToken()`
`JsonToken` `ParserMinimalBase.nextValue()`
`protected void` `ParserBase.reportInvalidNumber(String msg)`
`protected void` `ParserBase.reportOverflowInt()`
`protected void` `ParserBase.reportOverflowLong()`
`protected void` `ParserBase.reportUnexpectedNumberChar(int ch, String comment)`
`JsonParser` `ParserMinimalBase.skipChildren()`

Uses of JsonParseException in com.fasterxml.jackson.core.json

Methods in com.fasterxml.jackson.core.json that throw JsonParseException
`protected byte[]` `UTF8StreamJsonParser._decodeBase64(Base64Variant b64variant)` Efficient handling for incremental parsing of base64-encoded textual content.
`protected byte[]` `ReaderBasedJsonParser._decodeBase64(Base64Variant b64variant)` Efficient handling for incremental parsing of base64-encoded textual content.
`protected int` `UTF8StreamJsonParser._decodeCharForError(int firstByte)`
`protected char` `UTF8StreamJsonParser._decodeEscaped()`
`protected char` `ReaderBasedJsonParser._decodeEscaped()`
`protected void` `UTF8StreamJsonParser._finishString()`
`protected void` `ReaderBasedJsonParser._finishString()`
`protected void` `ReaderBasedJsonParser._finishString2()`
`protected JsonToken` `UTF8StreamJsonParser._handleApostropheValue()`
`protected JsonToken` `ReaderBasedJsonParser._handleApostropheValue()`
`protected JsonToken` `UTF8StreamJsonParser._handleInvalidNumberStart(int ch, boolean negative)` Method called if expected numeric value (due to leading sign) does not look like a number
`protected JsonToken` `ReaderBasedJsonParser._handleInvalidNumberStart(int ch, boolean negative)` Method called if expected numeric value (due to leading sign) does not look like a number
`protected JsonToken` `UTF8StreamJsonParser._handleUnexpectedValue(int c)` Method for handling cases where first non-space character of an expected value token is not legal for standard JSON content.
`protected JsonToken` `ReaderBasedJsonParser._handleUnexpectedValue(int i)` Method for handling cases where first non-space character of an expected value token is not legal for standard JSON content.
`protected Name` `UTF8StreamJsonParser._handleUnusualFieldName(int ch)` Method called when we see non-white space character other than double quote, when expecting a field name.
`protected String` `ReaderBasedJsonParser._handleUnusualFieldName(int i)` Method called when we see non-white space character other than double quote, when expecting a field name.
`protected void` `UTF8StreamJsonParser._matchToken(String matchStr, int i)`
`protected void` `ReaderBasedJsonParser._matchToken(String matchStr, int i)` Helper method for checking whether input matches expected token
`protected Name` `UTF8StreamJsonParser._parseApostropheFieldName()`
`protected String` `ReaderBasedJsonParser._parseApostropheFieldName()`
`protected Name` `UTF8StreamJsonParser._parseFieldName(int i)`
`protected String` `ReaderBasedJsonParser._parseFieldName(int i)`
`protected int` `UTF8StreamJsonParser._readBinary(Base64Variant b64variant, OutputStream out, byte[] buffer)`
`protected int` `ReaderBasedJsonParser._readBinary(Base64Variant b64variant, OutputStream out, byte[] buffer)`
`protected void` `UTF8StreamJsonParser._reportInvalidChar(int c)`
`protected void` `UTF8StreamJsonParser._reportInvalidInitial(int mask)`
`protected void` `UTF8StreamJsonParser._reportInvalidOther(int mask)`
`protected void` `UTF8StreamJsonParser._reportInvalidOther(int mask, int ptr)`
`protected void` `UTF8StreamJsonParser._reportInvalidToken(String matchedPart, String msg)`
`protected void` `ReaderBasedJsonParser._reportInvalidToken(String matchedPart, String msg)`
`protected void` `UTF8StreamJsonParser._skipString()` Method called to skim through rest of unparsed String value, if it is not needed.
`protected void` `ReaderBasedJsonParser._skipString()` Method called to skim through rest of unparsed String value, if it is not needed.
`JsonParser` `ByteSourceJsonBootstrapper.constructParser(int parserFeatures, ObjectCodec codec, BytesToNameCanonicalizer rootByteSymbols, CharsToNameCanonicalizer rootCharSymbols, boolean canonicalize, boolean intern)`
`JsonEncoding` `ByteSourceJsonBootstrapper.detectEncoding()` Method that should be called after constructing an instace.
`byte[]` `UTF8StreamJsonParser.getBinaryValue(Base64Variant b64variant)`
`byte[]` `ReaderBasedJsonParser.getBinaryValue(Base64Variant b64variant)`
`Object` `UTF8StreamJsonParser.getEmbeddedObject()`
`Object` `ReaderBasedJsonParser.getEmbeddedObject()`
`protected char` `ReaderBasedJsonParser.getNextChar(String eofMsg)`
`String` `UTF8StreamJsonParser.getText()`
`String` `ReaderBasedJsonParser.getText()` Method for accessing textual representation of the current event; if no current event (before first call to `ReaderBasedJsonParser.nextToken()`, or after encountering end-of-input), returns null.
`char[]` `UTF8StreamJsonParser.getTextCharacters()`
`char[]` `ReaderBasedJsonParser.getTextCharacters()`
`int` `UTF8StreamJsonParser.getTextLength()`
`int` `ReaderBasedJsonParser.getTextLength()`
`int` `UTF8StreamJsonParser.getTextOffset()`
`int` `ReaderBasedJsonParser.getTextOffset()`
`String` `UTF8StreamJsonParser.getValueAsString()`
`String` `ReaderBasedJsonParser.getValueAsString()`
`String` `UTF8StreamJsonParser.getValueAsString(String defValue)`
`String` `ReaderBasedJsonParser.getValueAsString(String defValue)`
`Boolean` `UTF8StreamJsonParser.nextBooleanValue()`
`Boolean` `ReaderBasedJsonParser.nextBooleanValue()`
`boolean` `UTF8StreamJsonParser.nextFieldName(SerializableString str)`
`int` `UTF8StreamJsonParser.nextIntValue(int defaultValue)`
`int` `ReaderBasedJsonParser.nextIntValue(int defaultValue)`
`long` `UTF8StreamJsonParser.nextLongValue(long defaultValue)`
`long` `ReaderBasedJsonParser.nextLongValue(long defaultValue)`
`String` `UTF8StreamJsonParser.nextTextValue()`
`String` `ReaderBasedJsonParser.nextTextValue()`
`JsonToken` `UTF8StreamJsonParser.nextToken()`
`JsonToken` `ReaderBasedJsonParser.nextToken()`
`protected Name` `UTF8StreamJsonParser.parseEscapedFieldName(int[] quads, int qlen, int currQuad, int ch, int currQuadBytes)` Slower parsing method which is generally branched to when an escape sequence is detected (or alternatively for long names, or ones crossing input buffer boundary).
`protected Name` `UTF8StreamJsonParser.parseLongFieldName(int q)`
`protected Name` `UTF8StreamJsonParser.parseMediumFieldName(int q2, int[] codes)`
`protected JsonToken` `UTF8StreamJsonParser.parseNumberText(int c)` Initial parsing method for number values.
`protected JsonToken` `ReaderBasedJsonParser.parseNumberText(int ch)` Initial parsing method for number values.
`int` `UTF8StreamJsonParser.readBinaryValue(Base64Variant b64variant, OutputStream out)`
`int` `ReaderBasedJsonParser.readBinaryValue(Base64Variant b64variant, OutputStream out)`
`protected Name` `UTF8StreamJsonParser.slowParseFieldName()` Method called when not even first 8 bytes are guaranteed to come consequtively.

Uses of JsonParseException in com.fasterxml.jackson.core.util

Methods in com.fasterxml.jackson.core.util that throw JsonParseException
`BigInteger` `JsonParserDelegate.getBigIntegerValue()`
`byte[]` `JsonParserDelegate.getBinaryValue(Base64Variant b64variant)`
`boolean` `JsonParserDelegate.getBooleanValue()`
`byte` `JsonParserDelegate.getByteValue()`
`String` `JsonParserDelegate.getCurrentName()`
`BigDecimal` `JsonParserDelegate.getDecimalValue()`
`double` `JsonParserDelegate.getDoubleValue()`
`Object` `JsonParserDelegate.getEmbeddedObject()`
`float` `JsonParserDelegate.getFloatValue()`
`int` `JsonParserDelegate.getIntValue()`
`long` `JsonParserDelegate.getLongValue()`
`JsonParser.NumberType` `JsonParserDelegate.getNumberType()`
`Number` `JsonParserDelegate.getNumberValue()`
`short` `JsonParserDelegate.getShortValue()`
`String` `JsonParserDelegate.getText()`
`char[]` `JsonParserDelegate.getTextCharacters()`
`int` `JsonParserDelegate.getTextLength()`
`int` `JsonParserDelegate.getTextOffset()`
`boolean` `JsonParserDelegate.getValueAsBoolean()`
`boolean` `JsonParserDelegate.getValueAsBoolean(boolean defaultValue)`
`double` `JsonParserDelegate.getValueAsDouble()`
`double` `JsonParserDelegate.getValueAsDouble(double defaultValue)`
`int` `JsonParserDelegate.getValueAsInt()`
`int` `JsonParserDelegate.getValueAsInt(int defaultValue)`
`long` `JsonParserDelegate.getValueAsLong()`
`long` `JsonParserDelegate.getValueAsLong(long defaultValue)`
`String` `JsonParserDelegate.getValueAsString()`
`String` `JsonParserDelegate.getValueAsString(String defaultValue)`
`JsonToken` `JsonParserSequence.nextToken()`
`JsonToken` `JsonParserDelegate.nextToken()`
`JsonToken` `JsonParserDelegate.nextValue()`
`int` `JsonParserDelegate.readBinaryValue(Base64Variant b64variant, OutputStream out)`
`JsonParser` `JsonParserDelegate.skipChildren()`

Copyright © 2012 FasterXML. All Rights Reserved.