ParserBase (jackson-core 2.18.1)

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:

JsonParserBase
```
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, JsonParser.NumberTypeFP

Field Summary

Fields
Modifier and Type	Field and 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 BigDecimal`	`_numberBigDecimal`
`protected BigInteger`	`_numberBigInt`
`protected double`	`_numberDouble`
`protected float`	`_numberFloat`
`protected int`	`_numberInt`
`protected boolean`	`_numberIsNaN` Marker for explicit "Not a Number" (NaN) values that may be read by some formats: this includes positive and negative infinity, as well as "NaN" result for some arithmetic operations.
`protected long`	`_numberLong`
`protected boolean`	`_numberNegative` Flag that indicates whether numeric value has a negative value.
`protected String`	`_numberString` Textual number representation captured from input in cases lazy-parsing is desired.
`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 JacksonFeatureSet<StreamReadCapability>`	`JSON_READ_CAPABILITIES`

Fields inherited from class com.fasterxml.jackson.core.base.ParserMinimalBase
_currToken, _lastClearedToken, _streamReadConstraints, _tokenCount, _trackMaxTokenCount, 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, DEFAULT_READ_CAPABILITIES

Constructor Summary

Constructors
Modifier Constructor and Description

protected ParserBase(IOContext ctxt, int features)

Constructors
Modifier	Constructor and 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 and Description
`protected void`	`_checkStdFeatureChanges(int newFeatureFlags, int changedFeatures)` Helper method called to verify changes to standard features.
`protected abstract void`	`_closeInput()`
`protected ContentReference`	`_contentReference()` Helper method used to encapsulate logic of including (or not) of "content reference" when constructing `JsonLocation` instances.
`protected ContentReference`	`_contentReferenceRedacted()` Helper method used to encapsulate logic of providing "content reference" when constructing `JsonLocation` instances and source information is NOT to be included (`StreamReadFeature.INCLUDE_SOURCE_IN_LOCATION` disabled).
`protected BigInteger`	`_convertBigDecimalToBigInteger(BigDecimal bigDec)`
`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()`
`protected BigDecimal`	`_getBigDecimal()` Internal accessor that needs to be used for accessing number value of type `BigDecimal` which -- as of 2.14 -- is typically lazily parsed.
`protected BigInteger`	`_getBigInteger()` Internal accessor that needs to be used for accessing number value of type `BigInteger` which -- as of 2.14 -- is typically lazily parsed.
`ByteArrayBuilder`	`_getByteArrayBuilder()`
`protected double`	`_getNumberDouble()` Internal accessor that needs to be used for accessing number value of type `double` which -- as of 2.15 -- will be lazily parsed.
`protected float`	`_getNumberFloat()` Internal accessor that needs to be used for accessing number value of type `float` which -- as of 2.15 -- will be lazily parsed.
`protected Object`	`_getSourceReference()` Deprecated. Since 2.13, use `_contentReference()` instead.
`protected int[]`	`_growNameDecodeBuffer(int[] arr, int more)`
`protected void`	`_handleBase64MissingPadding(Base64Variant b64variant)`
`protected void`	`_handleEOF()` Method called when an EOF is encountered between tokens.
`protected char`	`_handleUnrecognizedCharacterEscape(char ch)`
`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`	`_reportTooLongIntegral(int expType, String rawNum)`
`protected void`	`_throwUnquotedSpace(int i, String ctxtDesc)` Method called to report a problem with unquoted control character.
`protected String`	`_validJsonTokenList()`
`protected String`	`_validJsonValueList()`
`void`	`assignCurrentValue(Object v)` Helper method, usually equivalent to: `getParsingContext().setCurrentValue(v);`
`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`	`convertNumberToFloat()`
`protected void`	`convertNumberToInt()`
`protected void`	`convertNumberToLong()`
`protected void`	`createChildArrayContext(int lineNr, int colNr)`
`protected void`	`createChildObjectContext(int lineNr, int colNr)`
`Object`	`currentValue()` 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.
`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()` Deprecated.
`String`	`getCurrentName()` Deprecated.
`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.
`Object`	`getNumberValueDeferred()` Method similar to `JsonParser.getNumberValue()` but that returns either same `Number` value as `JsonParser.getNumberValue()` (if already decoded), or `String` representation of as-of-yet undecoded number.
`Number`	`getNumberValueExact()` Method similar to `JsonParser.getNumberValue()` with the difference that for floating-point numbers value returned may be `BigDecimal` if the underlying format does not store floating-point numbers using native representation: for example, textual formats represent numbers as Strings (which are 10-based), and conversion to `Double` is potentially lossy operation.
`JsonReadContext`	`getParsingContext()` Method that can be used to access current parsing context reader is in.
`long`	`getTokenCharacterOffset()`
`int`	`getTokenColumnNr()`
`int`	`getTokenLineNr()`
`JsonLocation`	`getTokenLocation()` Deprecated.
`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()` Accessor for checking whether current token is a special "not-a-number" (NaN) token (including both "NaN" AND positive/negative infinity!).
`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 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)`
`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, _currentLocationMinusOne, _decodeBase64, _getCharDesc, _hasTextualNull, _longIntegerDesc, _longNumberDesc, _nullSafeUpdateToken, _reportError, _reportError, _reportError, _reportInputCoercion, _reportInvalidEOF, _reportInvalidEOF, _reportInvalidEOFInValue, _reportMissingRootWS, _reportUnexpectedChar, _reportUnexpectedNumberChar, _throwInternal, _throwInternalReturnAny, _throwInvalidSpace, _updateToken, _updateTokenToNA, _updateTokenToNull, _wrapError, clearCurrentToken, currentToken, currentTokenCount, currentTokenId, getCurrentToken, getCurrentTokenId, getLastClearedToken, getText, getTextCharacters, getTextLength, getTextOffset, getValueAsBoolean, getValueAsDouble, getValueAsInt, getValueAsInt, getValueAsLong, getValueAsLong, getValueAsString, getValueAsString, hasCurrentToken, hasToken, hasTokenId, isExpectedNumberIntToken, isExpectedStartArrayToken, isExpectedStartObjectToken, nextToken, nextValue, reportInvalidNumber, reportOverflowInt, reportOverflowInt, reportOverflowInt, reportOverflowLong, reportOverflowLong, reportOverflowLong, reportUnexpectedNumberChar, skipChildren, streamReadConstraints

Methods inherited from class com.fasterxml.jackson.core.JsonParser
_codec, _constructError, _constructReadException, _constructReadException, _constructReadException, _constructReadException, _constructReadException, _constructReadException, _reportUnsupportedOperation, canParseAsync, canReadObjectId, canReadTypeId, canUseSchema, configure, currentLocation, currentName, currentTokenLocation, finishToken, getBinaryValue, getBooleanValue, getByteValue, getCodec, getCurrentValue, getEmbeddedObject, getFeatureMask, getFormatFeatures, getInputSource, getNonBlockingInputFeeder, getNumberTypeFP, getObjectId, getReadCapabilities, getSchema, getShortValue, getText, getTypeId, getValueAsBoolean, getValueAsDouble, isEnabled, isEnabled, nextBooleanValue, nextFieldName, nextFieldName, nextIntValue, nextLongValue, nextTextValue, overrideFormatFeatures, readBinaryValue, readBinaryValue, readValueAs, readValueAs, readValueAsTree, readValuesAs, readValuesAs, releaseBuffered, releaseBuffered, requiresCustomCodec, setCodec, setCurrentValue, setRequestPayloadOnError, setRequestPayloadOnError, setRequestPayloadOnError, setSchema

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

- Field Detail
  - JSON_READ_CAPABILITIES
```
protected static final JacksonFeatureSet<StreamReadCapability> JSON_READ_CAPABILITIES
```
  - _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
```
  - _numberFloat
```
protected float _numberFloat
```
  - _numberDouble
```
protected double _numberDouble
```
  - _numberBigInt
```
protected BigInteger _numberBigInt
```
  - _numberBigDecimal
```
protected BigDecimal _numberBigDecimal
```
  - _numberString
```
protected String _numberString
```
    Textual number representation captured from input in cases lazy-parsing is desired.
    
    Since:
    
    2.14
  - _numberIsNaN
```
protected boolean _numberIsNaN
```
    Marker for explicit "Not a Number" (NaN) values that may be read by some formats: this includes positive and negative infinity, as well as "NaN" result for some arithmetic operations.
    In case of JSON, such values can only be handled with non-standard processing: for some other formats they can be passed normally.
    NOTE: this marker is NOT set in case of value overflow/underflow for double or float values.
    
    Since:
    
    2.17
  - _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
    
    Returns:
    
    Version of this generator (derived from version declared for jackson-core jar that contains the class
  - currentValue
```
public Object currentValue()
```
    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:
    
    currentValue in class JsonParser
    
    Returns:
    
    "Current value" associated with the current input context (state) of this parser
  - assignCurrentValue
```
public void assignCurrentValue(Object v)
```
    Description copied from class: JsonParser
    
    Helper method, usually equivalent to: getParsingContext().setCurrentValue(v);
    
    Overrides:
    
    assignCurrentValue in class JsonParser
    
    Parameters:
    
    v - Current value to assign for the current input context of this parser
  - 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
    
    Parameters:
    
    f - Feature to enable
    
    Returns:
    
    This parser, to allow call chaining
  - 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
    
    Parameters:
    
    f - Feature to disable
    
    Returns:
    
    This parser, to allow call chaining
  - 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
    
    Parameters:
    
    newMask - Bit mask that defines set of features to enable
    
    Returns:
    
    This parser, to allow call chaining
  - 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
    
    Returns:
    
    This parser, to allow call chaining
  - _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
```
@Deprecated
public String getCurrentName()
                                  throws IOException
```
    Deprecated.
    
    Method that can be called to get the name associated with the current event.
    
    Specified by:
    
    getCurrentName in class ParserMinimalBase
    
    Returns:
    
    Name of the current field in the parsing context
    
    Throws:
    
    IOException - for low-level read issues, or JsonParseException for decoding problems
  - 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 - if there is either an underlying I/O problem
  - 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
    
    Returns:
    
    True if this parser instance has been closed
  - 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
    
    Returns:
    
    Stream input context (JsonStreamContext) associated with this parser
  - getTokenLocation
```
@Deprecated
public JsonLocation getTokenLocation()
```
    Deprecated.
    
    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
    
    Returns:
    
    Starting location of the token parser currently points to
  - getCurrentLocation
```
@Deprecated
public JsonLocation getCurrentLocation()
```
    Deprecated.
    
    Method that returns location of the last processed character; usually for error reporting purposes
    
    Specified by:
    
    getCurrentLocation in class JsonParser
    
    Returns:
    
    Location of the last processed input unit (byte or character)
  - 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 - for low-level read issues, or JsonParseException for decoding problems
  - 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 - Not thrown by base implementation but could be thrown by sub-classes
  - _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 if there is no open non-root context.
    
    Specified by:
    
    _handleEOF in class ParserMinimalBase
    
    Throws:
    
    JsonParseException - If end-of-content is not acceptable (for example, missing end-object or end-array tokens)
  - _eofAsNextChar
```
protected final int _eofAsNextChar()
                            throws JsonParseException
```
    Returns:
    
    If no exception is thrown, -1 which is used as marked for "end-of-input"
    
    Throws:
    
    JsonParseException - If check on _handleEOF() fails; usually because the current context is not root context (missing end markers in content)
    
    Since:
    
    2.4
  - _getByteArrayBuilder
```
public ByteArrayBuilder _getByteArrayBuilder()
```
  - reset
```
protected final JsonToken reset(boolean negative,
                                int intLen,
                                int fractLen,
                                int expLen)
                         throws IOException
```
    Throws:
    
    IOException
  - resetInt
```
protected final JsonToken resetInt(boolean negative,
                                   int intLen)
                            throws IOException
```
    Throws:
    
    IOException
  - resetFloat
```
protected final JsonToken resetFloat(boolean negative,
                                     int intLen,
                                     int fractLen,
                                     int expLen)
                              throws IOException
```
    Throws:
    
    IOException
  - resetAsNaN
```
protected final JsonToken resetAsNaN(String valueStr,
                                     double value)
                              throws IOException
```
    Throws:
    
    IOException
  - isNaN
```
public boolean isNaN()
              throws IOException
```
    Description copied from class: JsonParser
    
    Accessor for checking whether current token is a special "not-a-number" (NaN) token (including both "NaN" AND positive/negative infinity!). These values are not supported by all formats: JSON, for example, only supports them if JsonReadFeature.ALLOW_NON_NUMERIC_NUMBERS is enabled.
    NOTE: in case where numeric value is outside range of requested type -- most notably Float or Double -- and decoding results effectively in a NaN value, this method DOES NOT return true: only explicit incoming markers do. This is because value could still be accessed as a valid BigDecimal.
    
    Overrides:
    
    isNaN in class JsonParser
    
    Returns:
    
    True if the current token is reported as JsonToken.VALUE_NUMBER_FLOAT and represents a "Not a Number" value; false for other tokens and regular floating-point numbers.
    
    Throws:
    
    IOException - for low-level read issues, or JsonParseException for decoding problems
  - 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
    
    Returns:
    
    Numeric value of the current token in its most optimal representation
    
    Throws:
    
    IOException - Problem with access: JsonParseException if the current token is not numeric, or if decoding of the value fails (invalid format for numbers); plain IOException if underlying content read fails (possible if values are extracted lazily)
  - getNumberValueExact
```
public Number getNumberValueExact()
                           throws IOException
```
    Description copied from class: JsonParser
    
    Method similar to JsonParser.getNumberValue() with the difference that for floating-point numbers value returned may be BigDecimal if the underlying format does not store floating-point numbers using native representation: for example, textual formats represent numbers as Strings (which are 10-based), and conversion to Double is potentially lossy operation.
    Default implementation simply returns JsonParser.getNumberValue()
    
    Overrides:
    
    getNumberValueExact in class JsonParser
    
    Returns:
    
    Numeric value of the current token using most accurate representation
    
    Throws:
    
    IOException - Problem with access: JsonParseException if the current token is not numeric, or if decoding of the value fails (invalid format for numbers); plain IOException if underlying content read fails (possible if values are extracted lazily)
  - getNumberValueDeferred
```
public Object getNumberValueDeferred()
                              throws IOException
```
    Description copied from class: JsonParser
    
    Method similar to JsonParser.getNumberValue() but that returns either same Number value as JsonParser.getNumberValue() (if already decoded), or String representation of as-of-yet undecoded number. Typically textual formats allow deferred decoding from String, whereas binary formats either decode numbers eagerly or have binary representation from which to decode value to return.
    Same constraints apply to calling this method as to JsonParser.getNumberValue(): current token must be either JsonToken.VALUE_NUMBER_INT or JsonToken.VALUE_NUMBER_FLOAT; otherwise an exception is thrown
    Default implementation simply returns JsonParser.getNumberValue()
    
    Overrides:
    
    getNumberValueDeferred in class JsonParser
    
    Returns:
    
    Either Number (for already decoded numbers) or String (for deferred decoding).
    
    Throws:
    
    IOException - Problem with access: JsonParseException if the current token is not numeric, or if decoding of the value fails (invalid format for numbers); plain IOException if underlying content read fails (possible if values are extracted lazily)
  - 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
    
    Returns:
    
    Type of current number, if parser points to numeric token; null otherwise
    
    Throws:
    
    IOException - for low-level read issues, or JsonParseException for decoding problems
  - 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 InputCoercionException may be thrown to indicate numeric overflow/underflow.
    
    Specified by:
    
    getIntValue in class JsonParser
    
    Returns:
    
    Current number value as int (if numeric token within Java 32-bit signed int range); otherwise exception thrown
    
    Throws:
    
    IOException - for low-level read issues, or JsonParseException for decoding problems
  - 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 InputCoercionException may be thrown to indicate numeric overflow/underflow.
    
    Specified by:
    
    getLongValue in class JsonParser
    
    Returns:
    
    Current number value as long (if numeric token within Java 32-bit signed long range); otherwise exception thrown
    
    Throws:
    
    IOException - for low-level read issues, or JsonParseException for decoding problems
  - 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
    
    Returns:
    
    Current number value as BigInteger (if numeric token); otherwise exception thrown
    
    Throws:
    
    IOException - for low-level read issues, or JsonParseException for decoding problems
  - 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 InputCoercionException will be thrown to indicate numeric overflow/underflow.
    
    Specified by:
    
    getFloatValue in class JsonParser
    
    Returns:
    
    Current number value as float (if numeric token within Java float range); otherwise exception thrown
    
    Throws:
    
    IOException - for low-level read issues, or JsonParseException for decoding problems
  - 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 InputCoercionException will be thrown to indicate numeric overflow/underflow.
    
    Specified by:
    
    getDoubleValue in class JsonParser
    
    Returns:
    
    Current number value as double (if numeric token within Java double range); otherwise exception thrown
    
    Throws:
    
    IOException - for low-level read issues, or JsonParseException for decoding problems
  - 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
    
    Returns:
    
    Current number value as BigDecimal (if numeric token); otherwise exception thrown
    
    Throws:
    
    IOException - for low-level read issues, or JsonParseException for decoding problems
  - _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 - If there are problems reading content
    
    JsonParseException - If there are problems decoding number value
  - _parseIntValue
```
protected int _parseIntValue()
                      throws IOException
```
    Throws:
    
    IOException
  - _reportTooLongIntegral
```
protected void _reportTooLongIntegral(int expType,
                                      String rawNum)
                               throws IOException
```
    Throws:
    
    IOException
  - 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
  - convertNumberToFloat
```
protected void convertNumberToFloat()
                             throws IOException
```
    Throws:
    
    IOException
  - convertNumberToBigDecimal
```
protected void convertNumberToBigDecimal()
                                  throws IOException
```
    Throws:
    
    IOException
  - _convertBigDecimalToBigInteger
```
protected BigInteger _convertBigDecimalToBigInteger(BigDecimal bigDec)
                                             throws IOException
```
    Throws:
    
    IOException
  - _getBigInteger
```
protected BigInteger _getBigInteger()
                             throws JsonParseException
```
    Internal accessor that needs to be used for accessing number value of type BigInteger which -- as of 2.14 -- is typically lazily parsed.
    
    Returns:
    
    BigInteger value of the current token
    
    Throws:
    
    JsonParseException - If parsing fails
    
    Since:
    
    2.14
  - _getBigDecimal
```
protected BigDecimal _getBigDecimal()
                             throws JsonParseException
```
    Internal accessor that needs to be used for accessing number value of type BigDecimal which -- as of 2.14 -- is typically lazily parsed.
    
    Returns:
    
    BigDecimal value of the current token
    
    Throws:
    
    JsonParseException - If parsing fails
    
    Since:
    
    2.14
  - _getNumberDouble
```
protected double _getNumberDouble()
                           throws JsonParseException
```
    Internal accessor that needs to be used for accessing number value of type double which -- as of 2.15 -- will be lazily parsed.
    
    Returns:
    
    double value of the current token
    
    Throws:
    
    JsonParseException - If parsing fails
    
    Since:
    
    2.15
  - _getNumberFloat
```
protected float _getNumberFloat()
                         throws JsonParseException
```
    Internal accessor that needs to be used for accessing number value of type float which -- as of 2.15 -- will be lazily parsed.
    
    Returns:
    
    float value of the current token
    
    Throws:
    
    JsonParseException - If parsing fails
    
    Since:
    
    2.15
  - createChildArrayContext
```
protected void createChildArrayContext(int lineNr,
                                       int colNr)
                                throws IOException
```
    Throws:
    
    IOException
  - createChildObjectContext
```
protected void createChildObjectContext(int lineNr,
                                        int colNr)
                                 throws IOException
```
    Throws:
    
    IOException
  - _handleUnrecognizedCharacterEscape
```
protected char _handleUnrecognizedCharacterEscape(char ch)
                                           throws JsonProcessingException
```
    Throws:
    
    JsonProcessingException
  - _reportMismatchedEndMarker
```
protected void _reportMismatchedEndMarker(int actCh,
                                          char expCh)
                                   throws JsonParseException
```
    Throws:
    
    JsonParseException
  - _throwUnquotedSpace
```
protected void _throwUnquotedSpace(int i,
                                   String ctxtDesc)
                            throws JsonParseException
```
    Method called to report a problem with unquoted control character. Note: it is possible to suppress some instances of exception by enabling JsonReadFeature.ALLOW_UNESCAPED_CONTROL_CHARS.
    
    Parameters:
    
    i - Invalid control character
    
    ctxtDesc - Addition description of context to use in exception message
    
    Throws:
    
    JsonParseException - explaining the problem
  - _validJsonTokenList
```
protected String _validJsonTokenList()
                              throws IOException
```
    Returns:
    
    Description to use as "valid tokens" in an exception message about invalid (unrecognized) JSON token: called when parser finds something that looks like unquoted textual token
    
    Throws:
    
    IOException - Not thrown by base implementation but allowed by sub-classes
    
    Since:
    
    2.10
  - _validJsonValueList
```
protected String _validJsonValueList()
                              throws IOException
```
    Returns:
    
    Description to use as "valid JSON values" in an exception message about invalid (unrecognized) JSON value: called when parser finds something that does not look like a value or separator.
    
    Throws:
    
    IOException - Not thrown by base implementation but allowed by sub-classes
    
    Since:
    
    2.10
  - _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
    
    Returns:
    
    Character decoded, if any
    
    Throws:
    
    IOException - If escape decoding fails
  - _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
```
    Throws:
    
    IllegalArgumentException
  - _handleBase64MissingPadding
```
protected void _handleBase64MissingPadding(Base64Variant b64variant)
                                    throws IOException
```
    Throws:
    
    IOException
  - _getSourceReference
```
@Deprecated
protected Object _getSourceReference()
```
    Deprecated. Since 2.13, use _contentReference() instead.
    
    Returns:
    
    Source reference
    
    Since:
    
    2.9
  - _contentReference
```
protected ContentReference _contentReference()
```
    Helper method used to encapsulate logic of including (or not) of "content reference" when constructing JsonLocation instances.
    
    Returns:
    
    ContentReference object to use.
    
    Since:
    
    2.13
  - _contentReferenceRedacted
```
protected ContentReference _contentReferenceRedacted()
```
    Helper method used to encapsulate logic of providing "content reference" when constructing JsonLocation instances and source information is NOT to be included (StreamReadFeature.INCLUDE_SOURCE_IN_LOCATION disabled).
    Default implementation will simply return ContentReference.redacted().
    
    Returns:
    
    ContentReference object to use when source is not to be included
    
    Since:
    
    2.16
  - growArrayBy
```
protected static int[] growArrayBy(int[] arr,
                                   int more)
                            throws IllegalArgumentException
```
    Throws:
    
    IllegalArgumentException
  - _growNameDecodeBuffer
```
protected int[] _growNameDecodeBuffer(int[] arr,
                                      int more)
                               throws StreamConstraintsException
```
    Throws:
    
    StreamConstraintsException
  - 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

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

JSON_READ_CAPABILITIES

_ioContext

_closed

_inputPtr

_inputEnd

_currInputProcessed

_currInputRow

_currInputRowStart

_tokenInputTotal

_tokenInputRow

_tokenInputCol

_parsingContext

_nextToken

_textBuffer

_nameCopyBuffer

_nameCopied

_byteArrayBuilder

_binaryValue

_numTypesValid

_numberInt

_numberLong

_numberFloat

_numberDouble

_numberBigInt

_numberBigDecimal

_numberString

_numberIsNaN

_numberNegative

_intLength

_fractLength

_expLength

Constructor Detail

ParserBase

Method Detail

version

currentValue

assignCurrentValue

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

getNumberValueExact

getNumberValueDeferred

getNumberType