com.fasterxml.jackson.core.base

## Class ParserBase

- java.lang.Object
- - com.fasterxml.jackson.core.JsonParser
  - - com.fasterxml.jackson.core.base.ParserMinimalBase
    - - com.fasterxml.jackson.core.base.ParserBase

All Implemented Interfaces:
  Versioned, Closeable, AutoCloseable

Direct Known Subclasses:
  ReaderBasedJsonParser, UTF8DataInputJsonParser, UTF8StreamJsonParser

    public abstract class ParserBase
    extends ParserMinimalBase

Intermediate base class used by all Jackson `JsonParser` implementations. Contains most common things that are independent of actual underlying input source.

### Nested Class Summary

### Nested classes/interfaces inherited from class com.fasterxml.jackson.core.JsonParser

`JsonParser.Feature, JsonParser.NumberType`

### Field Summary

Fields
`protected byte[]` `_binaryValue` We will hold on to decoded binary data, for duration of current event, so that multiple calls to `getBinaryValue(com.fasterxml.jackson.core.Base64Variant)` will not need to decode data more than once.
`protected ByteArrayBuilder` `_byteArrayBuilder` ByteArrayBuilder is needed if 'getBinaryValue' is called.
`protected boolean` `_closed` Flag that indicates whether parser is closed or not.
`protected long` `_currInputProcessed` Number of characters/bytes that were contained in previous blocks (blocks that were already processed prior to the current buffer).
`protected int` `_currInputRow` Current row location of current point in input buffer, starting from 1, if available.
`protected int` `_currInputRowStart` Current index of the first character of the current row in input buffer.
`protected int` `_expLength` Length of the exponent part of the number, if any, not including 'e' marker or sign, just digits.
`protected int` `_fractLength` Length of the fractional part (not including decimal point or exponent), in characters.
`protected int` `_inputEnd` Index of character after last available one in the buffer.
`protected int` `_inputPtr` Pointer to next available character in buffer
`protected int` `_intLength` Length of integer part of the number, in characters
`protected IOContext` `_ioContext` I/O context for this reader.
`protected boolean` `_nameCopied` Flag set to indicate whether the field name is available from the name copy buffer or not (in addition to its String representation being available via read context)
`protected char[]` `_nameCopyBuffer` Temporary buffer that is needed if field name is accessed using `ParserMinimalBase.getTextCharacters()` method (instead of String returning alternatives)
`protected JsonToken` `_nextToken` Secondary token related to the next token after current one; used if its type is known.
`protected BigDecimal` `_numberBigDecimal`
`protected BigInteger` `_numberBigInt`
`protected double` `_numberDouble`
`protected int` `_numberInt`
`protected long` `_numberLong`
`protected boolean` `_numberNegative` Flag that indicates whether numeric value has a negative value.
`protected int` `_numTypesValid` Bitfield that indicates which numeric representations have been calculated for the current type
`protected JsonReadContext` `_parsingContext` Information about parser context, context in which the next token is to be parsed (root, array, object).
`protected TextBuffer` `_textBuffer` Buffer that contains contents of String values, including field names if necessary (name split across boundary, contains escape sequence, or access needed to char array)
`protected int` `_tokenInputCol` Column on input row that current token starts; 0-based (although in the end it'll be converted to 1-based)
`protected int` `_tokenInputRow` Input row on which current token starts, 1-based
`protected long` `_tokenInputTotal` Total number of bytes/characters read before start of current token.
`protected static char` `CHAR_NULL`
`protected static int` `INT_0`
`protected static int` `INT_9`
`protected static int` `INT_MINUS`
`protected static int` `INT_PLUS`
`protected static int` `MAX_ERROR_TOKEN_LENGTH` Maximum number of characters to include in token reported as part of error messages.
`protected static int` `NR_BIGDECIMAL`
`protected static int` `NR_BIGINT`
`protected static int` `NR_DOUBLE`
`protected static int` `NR_INT`
`protected static int` `NR_LONG`
`protected static int` `NR_UNKNOWN`

### Fields inherited from class com.fasterxml.jackson.core.base.ParserMinimalBase

`_currToken, _lastClearedToken, INT_BACKSLASH, INT_COLON, INT_COMMA, INT_CR, INT_e, INT_E, INT_HASH, INT_LBRACKET, INT_LCURLY, INT_LF, INT_PERIOD, INT_QUOTE, INT_RBRACKET, INT_RCURLY, INT_SLASH, INT_SPACE, INT_TAB`

### Fields inherited from class com.fasterxml.jackson.core.JsonParser

`_features, _requestPayload`

### Constructor Summary

Constructors
`protected` `ParserBase(IOContext ctxt, int features)`

### Method Summary

Methods
`protected void` `_checkStdFeatureChanges(int newFeatureFlags, int changedFeatures)` Helper method called to verify changes to standard features.
`protected abstract void` `_closeInput()`
`protected int` `_decodeBase64Escape(Base64Variant b64variant, char ch, int index)`
`protected int` `_decodeBase64Escape(Base64Variant b64variant, int ch, int index)`
`protected char` `_decodeEscaped()` Method that sub-classes must implement to support escaped sequences in base64-encoded sections.
`protected int` `_eofAsNextChar()`
`protected void` `_finishString()`
`ByteArrayBuilder` `_getByteArrayBuilder()`
`protected Object` `_getSourceReference()` Helper method used to encapsulate logic of including (or not) of "source reference" when constructing `JsonLocation` instances.
`protected void` `_handleEOF()` Method called when an EOF is encountered between tokens.
`protected int` `_parseIntValue()`
`protected void` `_parseNumericValue(int expType)` Method that will parse actual numeric value out of a syntactically valid number value.
`protected void` `_releaseBuffers()` Method called to release internal buffers owned by the base reader.
`protected void` `_reportMismatchedEndMarker(int actCh, char expCh)`
`void` `close()` Closes the parser so that no further iteration or data access can be made; will also close the underlying input source if parser either owns the input source, or feature `JsonParser.Feature.AUTO_CLOSE_SOURCE` is enabled.
`protected void` `convertNumberToBigDecimal()`
`protected void` `convertNumberToBigInteger()`
`protected void` `convertNumberToDouble()`
`protected void` `convertNumberToInt()`
`protected void` `convertNumberToLong()`
`JsonParser` `disable(JsonParser.Feature f)` Method for disabling specified feature (check `JsonParser.Feature` for list of features)
`JsonParser` `enable(JsonParser.Feature f)` Method for enabling specified parser feature (check `JsonParser.Feature` for list of features)
`BigInteger` `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[]` `getBinaryValue(Base64Variant variant)` 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.
`JsonLocation` `getCurrentLocation()` Method that returns location of the last processed character; usually for error reporting purposes
`String` `getCurrentName()` Method that can be called to get the name associated with the current event.
`Object` `getCurrentValue()` Helper method, usually equivalent to: `getParsingContext().getCurrentValue();`
`BigDecimal` `getDecimalValue()` Numeric accessor that can be called when the current token is of type `JsonToken.VALUE_NUMBER_FLOAT` or `JsonToken.VALUE_NUMBER_INT`.
`double` `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.
`float` `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.
`int` `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.
`long` `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.
`JsonParser.NumberType` `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.
`Number` `getNumberValue()` Generic number value accessor method that will work for all kinds of numeric values.
`JsonReadContext` `getParsingContext()` Method that can be used to access current parsing context reader is in.
`long` `getTokenCharacterOffset()`
`int` `getTokenColumnNr()`
`int` `getTokenLineNr()`
`JsonLocation` `getTokenLocation()` Method that return the starting location of the current token; that is, position of the first character from input that starts the current token.
`boolean` `hasTextCharacters()` Method that can be used to determine whether calling of `JsonParser.getTextCharacters()` would be the most efficient way to access textual content for the event parser currently points to.
`boolean` `isClosed()` Method that can be called to determine whether this parser is closed or not.
`protected boolean` `loadMore()` Deprecated.
`protected void` `loadMoreGuaranteed()` Deprecated.
`void` `overrideCurrentName(String name)` Method that can be used to change what is considered to be the current (field) name.
`JsonParser` `overrideStdFeatures(int values, int mask)` Bulk set method for (re)setting states of features specified by `mask`.
`protected IllegalArgumentException` `reportInvalidBase64Char(Base64Variant b64variant, int ch, int bindex)`
`protected IllegalArgumentException` `reportInvalidBase64Char(Base64Variant b64variant, int ch, int bindex, String msg)`
`protected void` `reportInvalidNumber(String msg)`
`protected void` `reportOverflowInt()`
`protected void` `reportOverflowLong()`
`protected void` `reportUnexpectedNumberChar(int ch, String comment)`
`protected JsonToken` `reset(boolean negative, int intLen, int fractLen, int expLen)`
`protected JsonToken` `resetAsNaN(String valueStr, double value)`
`protected JsonToken` `resetFloat(boolean negative, int intLen, int fractLen, int expLen)`
`protected JsonToken` `resetInt(boolean negative, int intLen)`
`void` `setCurrentValue(Object v)` Helper method, usually equivalent to: `getParsingContext().setCurrentValue(v);`
`JsonParser` `setFeatureMask(int newMask)` Deprecated.
`Version` `version()` Accessor for getting version of the core package, given a parser instance.

### Methods inherited from class com.fasterxml.jackson.core.base.ParserMinimalBase

`_ascii, _asciiBytes, _constructError, _decodeBase64, _getCharDesc, _handleUnrecognizedCharacterEscape, _hasTextualNull, _reportError, _reportError, _reportError, _reportInvalidEOF, _reportInvalidEOF, _reportInvalidEOF, _reportInvalidEOFInValue, _reportInvalidEOFInValue, _reportMissingRootWS, _reportUnexpectedChar, _throwInternal, _throwInvalidSpace, _throwUnquotedSpace, _wrapError, clearCurrentToken, currentToken, currentTokenId, getCurrentToken, getCurrentTokenId, getLastClearedToken, getText, getTextCharacters, getTextLength, getTextOffset, getValueAsBoolean, getValueAsDouble, getValueAsInt, getValueAsInt, getValueAsLong, getValueAsLong, getValueAsString, getValueAsString, hasCurrentToken, hasToken, hasTokenId, isExpectedStartArrayToken, isExpectedStartObjectToken, nextToken, nextValue, skipChildren`

### Methods inherited from class com.fasterxml.jackson.core.JsonParser

`_codec, _constructError, _reportUnsupportedOperation, canReadObjectId, canReadTypeId, canUseSchema, configure, finishToken, getBinaryValue, getBooleanValue, getByteValue, getCodec, getEmbeddedObject, getFeatureMask, getFormatFeatures, getInputSource, getObjectId, getSchema, getShortValue, getText, getTypeId, getValueAsBoolean, getValueAsDouble, isEnabled, nextBooleanValue, nextFieldName, nextFieldName, nextIntValue, nextLongValue, nextTextValue, overrideFormatFeatures, readBinaryValue, readBinaryValue, readValueAs, readValueAs, readValueAsTree, readValuesAs, readValuesAs, releaseBuffered, releaseBuffered, requiresCustomCodec, setCodec, setRequestPayloadOnError, setRequestPayloadOnError, setRequestPayloadOnError, setSchema`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Field Detail

#### MAX_ERROR_TOKEN_LENGTH

    protected static final int MAX_ERROR_TOKEN_LENGTH

Maximum number of characters to include in token reported as part of error messages.

Since:
  2.9
See Also:
  Constant Field Values

#### _ioContext

    protected final IOContext _ioContext

I/O context for this reader. It handles buffer allocation for the reader.

#### _closed

    protected boolean _closed

Flag that indicates whether parser is closed or not. Gets set when parser is either closed by explicit call (`close()`) or when end-of-input is reached.

#### _inputPtr

    protected int _inputPtr

Pointer to next available character in buffer

#### _inputEnd

    protected int _inputEnd

Index of character after last available one in the buffer.

#### _currInputProcessed

    protected long _currInputProcessed

Number of characters/bytes that were contained in previous blocks (blocks that were already processed prior to the current buffer).

#### _currInputRow

    protected int _currInputRow

Current row location of current point in input buffer, starting from 1, if available.

#### _currInputRowStart

    protected int _currInputRowStart

Current index of the first character of the current row in input buffer. Needed to calculate column position, if necessary; benefit of not having column itself is that this only has to be updated once per line.

#### _tokenInputTotal

    protected long _tokenInputTotal

Total number of bytes/characters read before start of current token. For big (gigabyte-sized) sizes are possible, needs to be long, unlike pointers and sizes related to in-memory buffers.

#### _tokenInputRow

    protected int _tokenInputRow

Input row on which current token starts, 1-based

#### _tokenInputCol

    protected int _tokenInputCol

Column on input row that current token starts; 0-based (although in the end it'll be converted to 1-based)

#### _parsingContext

    protected JsonReadContext _parsingContext

Information about parser context, context in which the next token is to be parsed (root, array, object).

#### _nextToken

    protected JsonToken _nextToken

Secondary token related to the next token after current one; used if its type is known. This may be value token that follows FIELD_NAME, for example.

#### _textBuffer

    protected final TextBuffer _textBuffer

Buffer that contains contents of String values, including field names if necessary (name split across boundary, contains escape sequence, or access needed to char array)

#### _nameCopyBuffer

    protected char[] _nameCopyBuffer

Temporary buffer that is needed if field name is accessed using `ParserMinimalBase.getTextCharacters()` method (instead of String returning alternatives)

#### _nameCopied

    protected boolean _nameCopied

Flag set to indicate whether the field name is available from the name copy buffer or not (in addition to its String representation being available via read context)

#### _byteArrayBuilder

    protected ByteArrayBuilder _byteArrayBuilder

ByteArrayBuilder is needed if 'getBinaryValue' is called. If so, we better reuse it for remainder of content.

#### _binaryValue

    protected byte[] _binaryValue

We will hold on to decoded binary data, for duration of current event, so that multiple calls to `getBinaryValue(com.fasterxml.jackson.core.Base64Variant)` will not need to decode data more than once.

#### NR_UNKNOWN

    protected static final int NR_UNKNOWN

See Also:
  Constant Field Values

#### NR_INT

    protected static final int NR_INT

See Also:
  Constant Field Values

#### NR_LONG

    protected static final int NR_LONG

See Also:
  Constant Field Values

#### NR_BIGINT

    protected static final int NR_BIGINT

See Also:
  Constant Field Values

#### NR_DOUBLE

    protected static final int NR_DOUBLE

See Also:
  Constant Field Values

#### NR_BIGDECIMAL

    protected static final int NR_BIGDECIMAL

See Also:
  Constant Field Values

#### INT_0

    protected static final int INT_0

See Also:
  Constant Field Values

#### INT_9

    protected static final int INT_9

See Also:
  Constant Field Values

#### INT_MINUS

    protected static final int INT_MINUS

See Also:
  Constant Field Values

#### INT_PLUS

    protected static final int INT_PLUS

See Also:
  Constant Field Values

#### CHAR_NULL

    protected static final char CHAR_NULL

See Also:
  Constant Field Values

#### _numTypesValid

    protected int _numTypesValid

Bitfield that indicates which numeric representations have been calculated for the current type

#### _numberInt

    protected int _numberInt

#### _numberLong

    protected long _numberLong

#### _numberDouble

    protected double _numberDouble

#### _numberBigInt

    protected BigInteger _numberBigInt

#### _numberBigDecimal

    protected BigDecimal _numberBigDecimal

#### _numberNegative

    protected boolean _numberNegative

Flag that indicates whether numeric value has a negative value. That is, whether its textual representation starts with minus character.

#### _intLength

    protected int _intLength

Length of integer part of the number, in characters

#### _fractLength

    protected int _fractLength

Length of the fractional part (not including decimal point or exponent), in characters. Not used for pure integer values.

#### _expLength

    protected int _expLength

Length of the exponent part of the number, if any, not including 'e' marker or sign, just digits. Not used for pure integer values.

### Constructor Detail

#### ParserBase

    protected ParserBase(IOContext ctxt,
              int features)

### Method Detail

#### version

    public Version version()

Description copied from class: `JsonParser`
Accessor for getting version of the core package, given a parser instance. Left for sub-classes to implement.

Specified by:
  `version` in interface `Versioned`
Specified by:
  `version` in class `JsonParser`

#### getCurrentValue

    public Object getCurrentValue()

Description copied from class: `JsonParser`
Helper method, usually equivalent to: `getParsingContext().getCurrentValue();`

Note that "current value" is NOT populated (or used) by Streaming parser; it is only used by higher-level data-binding functionality. The reason it is included here is that it can be stored and accessed hierarchically, and gets passed through data-binding.

Overrides:
  `getCurrentValue` in class `JsonParser`

#### setCurrentValue

    public void setCurrentValue(Object v)

Description copied from class: `JsonParser`
Helper method, usually equivalent to: `getParsingContext().setCurrentValue(v);`

Overrides:
  `setCurrentValue` in class `JsonParser`

#### enable

    public JsonParser enable(JsonParser.Feature f)

Description copied from class: `JsonParser`
Method for enabling specified parser feature (check `JsonParser.Feature` for list of features)

Overrides:
  `enable` in class `JsonParser`

#### disable

    public JsonParser disable(JsonParser.Feature f)

Description copied from class: `JsonParser`
Method for disabling specified feature (check `JsonParser.Feature` for list of features)

Overrides:
  `disable` in class `JsonParser`

#### setFeatureMask

    @Deprecated
    public JsonParser setFeatureMask(int newMask)

Deprecated.
Description copied from class: `JsonParser`
Bulk set method for (re)setting states of all standard `JsonParser.Feature`s

Overrides:
  `setFeatureMask` in class `JsonParser`
Returns:
  This parser object, to allow chaining of calls

#### overrideStdFeatures

    public JsonParser overrideStdFeatures(int values,
                                 int mask)

Description copied from class: `JsonParser`
Bulk set method for (re)setting states of features specified by `mask`. Functionally equivalent to `int oldState = getFeatureMask(); int newState = (oldState & ~mask) | (values & mask); setFeatureMask(newState);` but preferred as this lets caller more efficiently specify actual changes made.

Overrides:
  `overrideStdFeatures` in class `JsonParser`
Parameters:
  `values` - Bit mask of set/clear state for features to change
  `mask` - Bit mask of features to change

#### _checkStdFeatureChanges

    protected void _checkStdFeatureChanges(int newFeatureFlags,
                               int changedFeatures)

Helper method called to verify changes to standard features.

Parameters:
  `newFeatureFlags` - Bitflag of standard features after they were changed
  `changedFeatures` - Bitflag of standard features for which setting did change
Since:
  2.7

#### getCurrentName

    public String getCurrentName()
                          throws IOException

Method that can be called to get the name associated with the current event.

Specified by:
  `getCurrentName` in class `ParserMinimalBase`
Throws:
  `IOException`

#### overrideCurrentName

    public void overrideCurrentName(String name)

Description copied from class: `JsonParser`
Method that can be used to change what is considered to be the current (field) name. May be needed to support non-JSON data formats or unusual binding conventions; not needed for typical processing.

Note that use of this method should only be done as sort of last resort, as it is a work-around for regular operation.

Specified by:
  `overrideCurrentName` in class `ParserMinimalBase`
Parameters:
  `name` - Name to use as the current name; may be null.

#### close

    public void close()
               throws IOException

Description copied from class: `JsonParser`
Closes the parser so that no further iteration or data access can be made; will also close the underlying input source if parser either owns the input source, or feature `JsonParser.Feature.AUTO_CLOSE_SOURCE` is enabled. Whether parser owns the input source depends on factory method that was used to construct instance (so check `JsonFactory` for details, but the general idea is that if caller passes in closable resource (such as `InputStream` or `Reader`) parser does NOT own the source; but if it passes a reference (such as `File` or `URL` and creates stream or reader it does own them.

Specified by:
  `close` in interface `Closeable`
Specified by:
  `close` in interface `AutoCloseable`
Specified by:
  `close` in class `ParserMinimalBase`
Throws:
  `IOException`

#### isClosed

    public boolean isClosed()

Description copied from class: `JsonParser`
Method that can be called to determine whether this parser is closed or not. If it is closed, no new tokens can be retrieved by calling `JsonParser.nextToken()` (and the underlying stream may be closed). Closing may be due to an explicit call to `JsonParser.close()` or because parser has encountered end of input.

Specified by:
  `isClosed` in class `ParserMinimalBase`

#### getParsingContext

    public JsonReadContext getParsingContext()

Description copied from class: `JsonParser`
Method that can be used to access current parsing context reader is in. There are 3 different types: root, array and object contexts, with slightly different available information. Contexts are hierarchically nested, and can be used for example for figuring out part of the input document that correspond to specific array or object (for highlighting purposes, or error reporting). Contexts can also be used for simple xpath-like matching of input, if so desired.

Specified by:
  `getParsingContext` in class `ParserMinimalBase`

#### getTokenLocation

    public JsonLocation getTokenLocation()

Method that return the starting location of the current token; that is, position of the first character from input that starts the current token.

Specified by:
  `getTokenLocation` in class `JsonParser`

#### getCurrentLocation

    public JsonLocation getCurrentLocation()

Method that returns location of the last processed character; usually for error reporting purposes

Specified by:
  `getCurrentLocation` in class `JsonParser`

#### hasTextCharacters

    public boolean hasTextCharacters()

Description copied from class: `JsonParser`
Method that can be used to determine whether calling of `JsonParser.getTextCharacters()` would be the most efficient way to access textual content for the event parser currently points to.

Default implementation simply returns false since only actual implementation class has knowledge of its internal buffering state. Implementations are strongly encouraged to properly override this method, to allow efficient copying of content by other code.

Specified by:
  `hasTextCharacters` in class `ParserMinimalBase`
Returns:
  True if parser currently has character array that can be efficiently returned via `JsonParser.getTextCharacters()`; false means that it may or may not exist

#### getBinaryValue

    public byte[] getBinaryValue(Base64Variant variant)
                          throws IOException

Description copied from class: `JsonParser`
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. It works similar to getting String value via `JsonParser.getText()` and decoding result (except for decoding part), but should be significantly more performant.

Note that non-decoded textual contents of the current token are not guaranteed to be accessible after this method is called. Current implementation, for example, clears up textual content during decoding. Decoded binary content, however, will be retained until parser is advanced to the next event.

Specified by:
  `getBinaryValue` in class `ParserMinimalBase`
Parameters:
  `variant` - Expected variant of base64 encoded content (see `Base64Variants` for definitions of "standard" variants).
Returns:
  Decoded binary data
Throws:
  `IOException`

#### getTokenCharacterOffset

    public long getTokenCharacterOffset()

#### getTokenLineNr

    public int getTokenLineNr()

#### getTokenColumnNr

    public int getTokenColumnNr()

#### _closeInput

    protected abstract void _closeInput()
                                 throws IOException

Throws:
  `IOException`

#### _releaseBuffers

    protected void _releaseBuffers()
                            throws IOException

Method called to release internal buffers owned by the base reader. This may be called along with `_closeInput()` (for example, when explicitly closing this reader instance), or separately (if need be).

Throws:
  `IOException`

#### _handleEOF

    protected void _handleEOF()
                       throws JsonParseException

Method called when an EOF is encountered between tokens. If so, it may be a legitimate EOF, but only iff there is no open non-root context.

Specified by:
  `_handleEOF` in class `ParserMinimalBase`
Throws:
  `JsonParseException`

#### _eofAsNextChar

    protected final int _eofAsNextChar()
                                throws JsonParseException

Throws:
  `JsonParseException`
Since:
  2.4

#### _getByteArrayBuilder

    public ByteArrayBuilder _getByteArrayBuilder()

#### reset

    protected final JsonToken reset(boolean negative,
                  int intLen,
                  int fractLen,
                  int expLen)

#### resetInt

    protected final JsonToken resetInt(boolean negative,
                     int intLen)

#### resetFloat

    protected final JsonToken resetFloat(boolean negative,
                       int intLen,
                       int fractLen,
                       int expLen)

#### resetAsNaN

    protected final JsonToken resetAsNaN(String valueStr,
                       double value)

#### getNumberValue

    public Number getNumberValue()
                          throws IOException

Description copied from class: `JsonParser`
Generic number value accessor method that will work for all kinds of numeric values. It will return the optimal (simplest/smallest possible) wrapper object that can express the numeric value just parsed.

Specified by:
  `getNumberValue` in class `JsonParser`
Throws:
  `IOException`

#### getNumberType

    public JsonParser.NumberType getNumberType()
                                        throws IOException

Description copied from class: `JsonParser`
If current token is of type `JsonToken.VALUE_NUMBER_INT` or `JsonToken.VALUE_NUMBER_FLOAT`, returns one of `JsonParser.NumberType` constants; otherwise returns null.

Specified by:
  `getNumberType` in class `JsonParser`
Throws:
  `IOException`

#### getIntValue

    public int getIntValue()
                    throws IOException

Description copied from class: `JsonParser`
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. It can also be called for `JsonToken.VALUE_NUMBER_FLOAT`; if so, it is equivalent to calling `JsonParser.getDoubleValue()` and then casting; except for possible overflow/underflow exception.

Note: if the resulting integer value falls outside range of Java int, a `JsonParseException` may be thrown to indicate numeric overflow/underflow.

Specified by:
  `getIntValue` in class `JsonParser`
Throws:
  `IOException`

#### getLongValue

    public long getLongValue()
                      throws IOException

Description copied from class: `JsonParser`
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. It can also be called for `JsonToken.VALUE_NUMBER_FLOAT`; if so, it is equivalent to calling `JsonParser.getDoubleValue()` and then casting to int; except for possible overflow/underflow exception.

Note: if the token is an integer, but its value falls outside of range of Java long, a `JsonParseException` may be thrown to indicate numeric overflow/underflow.

Specified by:
  `getLongValue` in class `JsonParser`
Throws:
  `IOException`

#### getBigIntegerValue

    public BigInteger getBigIntegerValue()
                                  throws IOException

Description copied from class: `JsonParser`
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. It can also be called for `JsonToken.VALUE_NUMBER_FLOAT`; if so, it is equivalent to calling `JsonParser.getDecimalValue()` and then constructing a `BigInteger` from that value.

Specified by:
  `getBigIntegerValue` in class `JsonParser`
Throws:
  `IOException`

#### getFloatValue

    public float getFloatValue()
                        throws IOException

Description copied from class: `JsonParser`
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. It can also be called for `JsonToken.VALUE_NUMBER_INT`; if so, it is equivalent to calling `JsonParser.getLongValue()` and then casting; except for possible overflow/underflow exception.

Note: if the value falls outside of range of Java float, a `JsonParseException` will be thrown to indicate numeric overflow/underflow.

Specified by:
  `getFloatValue` in class `JsonParser`
Throws:
  `IOException`

#### getDoubleValue

    public double getDoubleValue()
                          throws IOException

Description copied from class: `JsonParser`
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. It can also be called for `JsonToken.VALUE_NUMBER_INT`; if so, it is equivalent to calling `JsonParser.getLongValue()` and then casting; except for possible overflow/underflow exception.

Note: if the value falls outside of range of Java double, a `JsonParseException` will be thrown to indicate numeric overflow/underflow.

Specified by:
  `getDoubleValue` in class `JsonParser`
Throws:
  `IOException`

#### getDecimalValue

    public BigDecimal getDecimalValue()
                               throws IOException

Description copied from class: `JsonParser`
Numeric accessor that can be called when the current token is of type `JsonToken.VALUE_NUMBER_FLOAT` or `JsonToken.VALUE_NUMBER_INT`. No under/overflow exceptions are ever thrown.

Specified by:
  `getDecimalValue` in class `JsonParser`
Throws:
  `IOException`

#### _parseNumericValue

    protected void _parseNumericValue(int expType)
                               throws IOException

Method that will parse actual numeric value out of a syntactically valid number value. Type it will parse into depends on whether it is a floating point number, as well as its magnitude: smallest legal type (of ones available) is used for efficiency.

Parameters:
  `expType` - Numeric type that we will immediately need, if any; mostly necessary to optimize handling of floating point numbers
Throws:
  `IOException`

#### _parseIntValue

    protected int _parseIntValue()
                          throws IOException

Throws:
  `IOException`
Since:
  2.6

#### convertNumberToInt

    protected void convertNumberToInt()
                               throws IOException

Throws:
  `IOException`

#### convertNumberToLong

    protected void convertNumberToLong()
                                throws IOException

Throws:
  `IOException`

#### convertNumberToBigInteger

    protected void convertNumberToBigInteger()
                                      throws IOException

Throws:
  `IOException`

#### convertNumberToDouble

    protected void convertNumberToDouble()
                                  throws IOException

Throws:
  `IOException`

#### convertNumberToBigDecimal

    protected void convertNumberToBigDecimal()
                                      throws IOException

Throws:
  `IOException`

#### _reportMismatchedEndMarker

    protected void _reportMismatchedEndMarker(int actCh,
                                  char expCh)
                                       throws JsonParseException

Throws:
  `JsonParseException`

#### reportUnexpectedNumberChar

    protected void reportUnexpectedNumberChar(int ch,
                                  String comment)
                                       throws JsonParseException

Throws:
  `JsonParseException`

#### reportInvalidNumber

    protected void reportInvalidNumber(String msg)
                                throws JsonParseException

Throws:
  `JsonParseException`

#### reportOverflowInt

    protected void reportOverflowInt()
                              throws IOException

Throws:
  `IOException`

#### reportOverflowLong

    protected void reportOverflowLong()
                               throws IOException

Throws:
  `IOException`

#### _decodeEscaped

    protected char _decodeEscaped()
                           throws IOException

Method that sub-classes must implement to support escaped sequences in base64-encoded sections. Sub-classes that do not need base64 support can leave this as is

Throws:
  `IOException`

#### _decodeBase64Escape

    protected final int _decodeBase64Escape(Base64Variant b64variant,
                          int ch,
                          int index)
                                     throws IOException

Throws:
  `IOException`

#### _decodeBase64Escape

    protected final int _decodeBase64Escape(Base64Variant b64variant,
                          char ch,
                          int index)
                                     throws IOException

Throws:
  `IOException`

#### reportInvalidBase64Char

    protected IllegalArgumentException reportInvalidBase64Char(Base64Variant b64variant,
                                                   int ch,
                                                   int bindex)
                                                        throws IllegalArgumentException

Throws:
  `IllegalArgumentException`

#### reportInvalidBase64Char

    protected IllegalArgumentException reportInvalidBase64Char(Base64Variant b64variant,
                                                   int ch,
                                                   int bindex,
                                                   String msg)
                                                        throws IllegalArgumentException

Parameters:
  `bindex` - Relative index within base64 character unit; between 0 and 3 (as unit has exactly 4 characters)
Throws:
  `IllegalArgumentException`

#### _getSourceReference

    protected Object _getSourceReference()

Helper method used to encapsulate logic of including (or not) of "source reference" when constructing `JsonLocation` instances.

Since:
  2.9

#### loadMoreGuaranteed

    @Deprecated
    protected void loadMoreGuaranteed()
                               throws IOException

Deprecated.

Throws:
  `IOException`

#### loadMore

    @Deprecated
    protected boolean loadMore()
                        throws IOException

Deprecated.

Throws:
  `IOException`

#### _finishString

    protected void _finishString()
                          throws IOException

Throws:
  `IOException`