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

All Implemented Interfaces:

Versioned, java.io.Closeable, java.lang.AutoCloseable

Direct Known Subclasses:

NonBlockingJsonParserBase, 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
Modifier and Type	Field	Description
`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 java.math.BigDecimal`	`_numberBigDecimal`
`protected java.math.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.

Fields inherited from class com.fasterxml.jackson.core.base.ParserMinimalBase
_currToken, _lastClearedToken, BD_MAX_INT, BD_MAX_LONG, BD_MIN_INT, BD_MIN_LONG, BI_MAX_INT, BI_MAX_LONG, BI_MIN_INT, BI_MIN_LONG, CHAR_NULL, INT_0, INT_9, INT_APOS, INT_ASTERISK, INT_BACKSLASH, INT_COLON, INT_COMMA, INT_CR, INT_e, INT_E, INT_HASH, INT_LBRACKET, INT_LCURLY, INT_LF, INT_MINUS, INT_PERIOD, INT_PLUS, INT_QUOTE, INT_RBRACKET, INT_RCURLY, INT_SLASH, INT_SPACE, INT_TAB, MAX_ERROR_TOKEN_LENGTH, MAX_INT_D, MAX_INT_L, MAX_LONG_D, MIN_INT_D, MIN_INT_L, MIN_LONG_D, NO_BYTES, NO_INTS, NR_BIGDECIMAL, NR_BIGINT, NR_DOUBLE, NR_FLOAT, NR_INT, NR_LONG, NR_UNKNOWN

Fields inherited from class com.fasterxml.jackson.core.JsonParser
_features, _requestPayload

Constructor Summary

Constructors
Modifier Constructor Description

protected ParserBase(IOContext ctxt, int features)

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`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 java.lang.Object`	`_getSourceReference()`	Helper method used to encapsulate logic of including (or not) of "source reference" when constructing `JsonLocation` instances.
`protected void`	`_handleBase64MissingPadding(Base64Variant b64variant)`
`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)`
`protected void`	`_reportTooLongInt(int expType, java.lang.String rawNum)`
`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)
`java.math.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
`java.lang.String`	`getCurrentName()`	Method that can be called to get the name associated with the current event.
`java.lang.Object`	`getCurrentValue()`	Helper method, usually equivalent to: `getParsingContext().getCurrentValue();`
`java.math.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.
`java.lang.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.
`protected static int[]`	`growArrayBy(int[] arr, int more)`
`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.
`boolean`	`isNaN()`	Access for checking whether current token is a numeric value token, but one that is of "not-a-number" (NaN) variety (including both "NaN" AND positive/negative infinity!): not supported by all formats, but often supported for `JsonToken.VALUE_NUMBER_FLOAT`.
`protected boolean`	`loadMore()`	Deprecated.
`protected void`	`loadMoreGuaranteed()`	Deprecated.
`void`	`overrideCurrentName(java.lang.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 java.lang.IllegalArgumentException`	`reportInvalidBase64Char(Base64Variant b64variant, int ch, int bindex)`
`protected java.lang.IllegalArgumentException`	`reportInvalidBase64Char(Base64Variant b64variant, int ch, int bindex, java.lang.String msg)`
`protected JsonToken`	`reset(boolean negative, int intLen, int fractLen, int expLen)`
`protected JsonToken`	`resetAsNaN(java.lang.String valueStr, double value)`
`protected JsonToken`	`resetFloat(boolean negative, int intLen, int fractLen, int expLen)`
`protected JsonToken`	`resetInt(boolean negative, int intLen)`
`void`	`setCurrentValue(java.lang.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, _longIntegerDesc, _longNumberDesc, _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, reportInvalidNumber, reportOverflowInt, reportOverflowLong, reportUnexpectedNumberChar, skipChildren

Methods inherited from class com.fasterxml.jackson.core.JsonParser
_codec, _constructError, _reportUnsupportedOperation, canParseAsync, canReadObjectId, canReadTypeId, canUseSchema, configure, currentName, finishToken, getBinaryValue, getBooleanValue, getByteValue, getCodec, getEmbeddedObject, getFeatureMask, getFormatFeatures, getInputSource, getNonBlockingInputFeeder, 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
  - _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.
  - _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 java.math.BigInteger _numberBigInt
```
  - _numberBigDecimal
```
protected java.math.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 java.lang.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(java.lang.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.Features
    
    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 java.lang.String getCurrentName()
                                throws java.io.IOException
```
    Method that can be called to get the name associated with the current event.
    
    Specified by:
    
    getCurrentName in class ParserMinimalBase
    
    Throws:
    
    java.io.IOException
  - overrideCurrentName
```
public void overrideCurrentName(java.lang.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 java.io.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 java.lang.AutoCloseable
    
    Specified by:
    
    close in interface java.io.Closeable
    
    Specified by:
    
    close in class ParserMinimalBase
    
    Throws:
    
    java.io.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 java.io.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:
    
    java.io.IOException
  - getTokenCharacterOffset
```
public long getTokenCharacterOffset()
```
  - getTokenLineNr
```
public int getTokenLineNr()
```
  - getTokenColumnNr
```
public int getTokenColumnNr()
```
  - _closeInput
```
protected abstract void _closeInput()
                             throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - _releaseBuffers
```
protected void _releaseBuffers()
                        throws java.io.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:
    
    java.io.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(java.lang.String valueStr,
                                     double value)
```
  - isNaN
```
public boolean isNaN()
```
    Description copied from class: JsonParser
    
    Access for checking whether current token is a numeric value token, but one that is of "not-a-number" (NaN) variety (including both "NaN" AND positive/negative infinity!): not supported by all formats, but often supported for JsonToken.VALUE_NUMBER_FLOAT. NOTE: roughly equivalent to calling !Double.isFinite() on value you would get from calling JsonParser.getDoubleValue().
    
    Overrides:
    
    isNaN in class JsonParser
  - getNumberValue
```
public java.lang.Number getNumberValue()
                                throws java.io.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:
    
    java.io.IOException
  - getNumberType
```
public JsonParser.NumberType getNumberType()
                                    throws java.io.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:
    
    java.io.IOException
  - getIntValue
```
public int getIntValue()
                throws java.io.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:
    
    java.io.IOException
  - getLongValue
```
public long getLongValue()
                  throws java.io.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:
    
    java.io.IOException
  - getBigIntegerValue
```
public java.math.BigInteger getBigIntegerValue()
                                        throws java.io.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:
    
    java.io.IOException
  - getFloatValue
```
public float getFloatValue()
                    throws java.io.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:
    
    java.io.IOException
  - getDoubleValue
```
public double getDoubleValue()
                      throws java.io.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:
    
    java.io.IOException
  - getDecimalValue
```
public java.math.BigDecimal getDecimalValue()
                                     throws java.io.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:
    
    java.io.IOException
  - _parseNumericValue
```
protected void _parseNumericValue(int expType)
                           throws java.io.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:
    
    java.io.IOException
  - _parseIntValue
```
protected int _parseIntValue()
                      throws java.io.IOException
```
    Throws:
    
    java.io.IOException
    
    Since:
    
    2.6
  - _reportTooLongInt
```
protected void _reportTooLongInt(int expType,
                                 java.lang.String rawNum)
                          throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - convertNumberToInt
```
protected void convertNumberToInt()
                           throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - convertNumberToLong
```
protected void convertNumberToLong()
                            throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - convertNumberToBigInteger
```
protected void convertNumberToBigInteger()
                                  throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - convertNumberToDouble
```
protected void convertNumberToDouble()
                              throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - convertNumberToBigDecimal
```
protected void convertNumberToBigDecimal()
                                  throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - _reportMismatchedEndMarker
```
protected void _reportMismatchedEndMarker(int actCh,
                                          char expCh)
                                   throws JsonParseException
```
    Throws:
    
    JsonParseException
  - _decodeEscaped
```
protected char _decodeEscaped()
                       throws java.io.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:
    
    java.io.IOException
  - _decodeBase64Escape
```
protected final int _decodeBase64Escape(Base64Variant b64variant,
                                        int ch,
                                        int index)
                                 throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - _decodeBase64Escape
```
protected final int _decodeBase64Escape(Base64Variant b64variant,
                                        char ch,
                                        int index)
                                 throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - reportInvalidBase64Char
```
protected java.lang.IllegalArgumentException reportInvalidBase64Char(Base64Variant b64variant,
                                                                     int ch,
                                                                     int bindex)
                                                              throws java.lang.IllegalArgumentException
```
    Throws:
    
    java.lang.IllegalArgumentException
  - reportInvalidBase64Char
```
protected java.lang.IllegalArgumentException reportInvalidBase64Char(Base64Variant b64variant,
                                                                     int ch,
                                                                     int bindex,
                                                                     java.lang.String msg)
                                                              throws java.lang.IllegalArgumentException
```
    Parameters:
    
    bindex - Relative index within base64 character unit; between 0 and 3 (as unit has exactly 4 characters)
    
    Throws:
    
    java.lang.IllegalArgumentException
  - _handleBase64MissingPadding
```
protected void _handleBase64MissingPadding(Base64Variant b64variant)
                                    throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - _getSourceReference
```
protected java.lang.Object _getSourceReference()
```
    Helper method used to encapsulate logic of including (or not) of "source reference" when constructing JsonLocation instances.
    
    Since:
    
    2.9
  - growArrayBy
```
protected static int[] growArrayBy(int[] arr,
                                   int more)
```
  - loadMoreGuaranteed
```
@Deprecated
protected void loadMoreGuaranteed()
                           throws java.io.IOException
```
    Deprecated.
    
    Throws:
    
    java.io.IOException
  - loadMore
```
@Deprecated
protected boolean loadMore()
                    throws java.io.IOException
```
    Deprecated.
    
    Throws:
    
    java.io.IOException
  - _finishString
```
protected void _finishString()
                      throws java.io.IOException
```
    Throws:
    
    java.io.IOException

Class ParserBase

Nested Class Summary

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

Field Summary

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

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

Constructor Summary

Method Summary

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

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

Methods inherited from class java.lang.Object

Field Detail

_ioContext

_closed

_inputPtr

_inputEnd

_currInputProcessed

_currInputRow

_currInputRowStart

_tokenInputTotal

_tokenInputRow

_tokenInputCol

_parsingContext

_nextToken

_textBuffer

_nameCopyBuffer

_nameCopied

_byteArrayBuilder

_binaryValue

_numTypesValid

_numberInt

_numberLong

_numberDouble

_numberBigInt

_numberBigDecimal

_numberNegative

_intLength

_fractLength

_expLength

Constructor Detail

ParserBase

Method Detail

version

getCurrentValue

setCurrentValue

enable

disable

setFeatureMask

overrideStdFeatures

_checkStdFeatureChanges

getCurrentName

overrideCurrentName

close

isClosed

getParsingContext

getTokenLocation

getCurrentLocation

hasTextCharacters

getBinaryValue

getTokenCharacterOffset

getTokenLineNr

getTokenColumnNr

_closeInput

_releaseBuffers

_handleEOF

_eofAsNextChar

_getByteArrayBuilder

reset

resetInt

resetFloat

resetAsNaN

isNaN

getNumberValue

getNumberType

getIntValue

getLongValue

getBigIntegerValue

getFloatValue

getDoubleValue

getDecimalValue