ParserBase (jackson-core 2.6.2)

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

All Implemented Interfaces:

Versioned, Closeable, AutoCloseable

Direct Known Subclasses:

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

Fields inherited from class com.fasterxml.jackson.core.base.ParserMinimalBase
_currToken, _lastClearedToken, INT_BACKSLASH, INT_COLON, INT_COMMA, INT_CR, INT_e, INT_E, INT_HASH, INT_LBRACKET, INT_LCURLY, INT_LF, INT_PERIOD, INT_QUOTE, INT_RBRACKET, INT_RCURLY, INT_SLASH, INT_SPACE, INT_TAB

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

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

Methods
Modifier and Type	Method and Description
`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 abstract void`	`_finishString()`
`ByteArrayBuilder`	`_getByteArrayBuilder()`
`protected void`	`_handleEOF()` Method called when an EOF is encountered between tokens.
`protected int`	`_parseIntValue()`
`protected void`	`_parseNumericValue(int expType)` Method that will parse actual numeric value out of a syntactically valid number value.
`protected void`	`_releaseBuffers()` Method called to release internal buffers owned by the base reader.
`protected void`	`_reportMismatchedEndMarker(int actCh, char expCh)`
`void`	`close()` Closes the parser so that no further iteration or data access can be made; will also close the underlying input source if parser either owns the input source, or feature `JsonParser.Feature.AUTO_CLOSE_SOURCE` is enabled.
`protected void`	`convertNumberToBigDecimal()`
`protected void`	`convertNumberToBigInteger()`
`protected void`	`convertNumberToDouble()`
`protected void`	`convertNumberToInt()`
`protected void`	`convertNumberToLong()`
`JsonParser`	`disable(JsonParser.Feature f)` Method for disabling specified feature (check `JsonParser.Feature` for list of features)
`JsonParser`	`enable(JsonParser.Feature f)` Method for enabling specified parser feature (check `JsonParser.Feature` for list of features)
`BigInteger`	`getBigIntegerValue()` Numeric accessor that can be called when the current token is of type `JsonToken.VALUE_NUMBER_INT` and it can not be used as a Java long primitive type due to its magnitude.
`JsonLocation`	`getCurrentLocation()` Method that returns location of the last processed character; usually for error reporting purposes
`String`	`getCurrentName()` Method that can be called to get the name associated with the current event.
`Object`	`getCurrentValue()` Helper method, usually equivalent to: `getParsingContext().getCurrentValue();`
`BigDecimal`	`getDecimalValue()` Numeric accessor that can be called when the current token is of type `JsonToken.VALUE_NUMBER_FLOAT` or `JsonToken.VALUE_NUMBER_INT`.
`double`	`getDoubleValue()` Numeric accessor that can be called when the current token is of type `JsonToken.VALUE_NUMBER_FLOAT` and it can be expressed as a Java double primitive type.
`Object`	`getEmbeddedObject()` Accessor that can be called if (and only if) the current token is `JsonToken.VALUE_EMBEDDED_OBJECT`.
`float`	`getFloatValue()` Numeric accessor that can be called when the current token is of type `JsonToken.VALUE_NUMBER_FLOAT` and it can be expressed as a Java float primitive type.
`int`	`getIntValue()` Numeric accessor that can be called when the current token is of type `JsonToken.VALUE_NUMBER_INT` and it can be expressed as a value of Java int primitive type.
`long`	`getLongValue()` Numeric accessor that can be called when the current token is of type `JsonToken.VALUE_NUMBER_INT` and it can be expressed as a Java long primitive type.
`JsonParser.NumberType`	`getNumberType()` If current token is of type `JsonToken.VALUE_NUMBER_INT` or `JsonToken.VALUE_NUMBER_FLOAT`, returns one of `JsonParser.NumberType` constants; otherwise returns null.
`Number`	`getNumberValue()` Generic number value accessor method that will work for all kinds of numeric values.
`JsonReadContext`	`getParsingContext()` Method that can be used to access current parsing context reader is in.
`long`	`getTokenCharacterOffset()`
`int`	`getTokenColumnNr()`
`int`	`getTokenLineNr()`
`JsonLocation`	`getTokenLocation()` Method that return the starting location of the current token; that is, position of the first character from input that starts the current token.
`boolean`	`hasTextCharacters()` Method that can be used to determine whether calling of `JsonParser.getTextCharacters()` would be the most efficient way to access textual content for the event parser currently points to.
`boolean`	`isClosed()` Method that can be called to determine whether this parser is closed or not.
`protected abstract boolean`	`loadMore()`
`protected void`	`loadMoreGuaranteed()`
`void`	`overrideCurrentName(String name)` Method that can be used to change what is considered to be the current (field) name.
`protected IllegalArgumentException`	`reportInvalidBase64Char(Base64Variant b64variant, int ch, int bindex)`
`protected IllegalArgumentException`	`reportInvalidBase64Char(Base64Variant b64variant, int ch, int bindex, String msg)`
`protected void`	`reportInvalidNumber(String msg)`
`protected void`	`reportOverflowInt()`
`protected void`	`reportOverflowLong()`
`protected void`	`reportUnexpectedNumberChar(int ch, String comment)`
`protected JsonToken`	`reset(boolean negative, int intLen, int fractLen, int expLen)`
`protected JsonToken`	`resetAsNaN(String valueStr, double value)`
`protected JsonToken`	`resetFloat(boolean negative, int intLen, int fractLen, int expLen)`
`protected JsonToken`	`resetInt(boolean negative, int intLen)`
`void`	`setCurrentValue(Object v)` Helper method, usually equivalent to: `getParsingContext().setCurrentValue(v);`
`JsonParser`	`setFeatureMask(int newMask)` Bulk set method for (re)setting states of all standard `JsonParser.Feature`s
`Version`	`version()` Accessor for getting version of the core package, given a parser instance.

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 ParserMinimalBase.getBinaryValue(com.fasterxml.jackson.core.Base64Variant) will not need to decode data more than once.
  - NR_UNKNOWN
```
protected static final int NR_UNKNOWN
```
    See Also:
    Constant Field Values
  - NR_INT
```
protected static final int NR_INT
```
    See Also:
    Constant Field Values
  - NR_LONG
```
protected static final int NR_LONG
```
    See Also:
    Constant Field Values
  - NR_BIGINT
```
protected static final int NR_BIGINT
```
    See Also:
    Constant Field Values
  - NR_DOUBLE
```
protected static final int NR_DOUBLE
```
    See Also:
    Constant Field Values
  - NR_BIGDECIMAL
```
protected static final int NR_BIGDECIMAL
```
    See Also:
    Constant Field Values
  - INT_0
```
protected static final int INT_0
```
    See Also:
    Constant Field Values
  - INT_9
```
protected static final int INT_9
```
    See Also:
    Constant Field Values
  - INT_MINUS
```
protected static final int INT_MINUS
```
    See Also:
    Constant Field Values
  - INT_PLUS
```
protected static final int INT_PLUS
```
    See Also:
    Constant Field Values
  - CHAR_NULL
```
protected static final char CHAR_NULL
```
    See Also:
    Constant Field Values
  - _numTypesValid
```
protected int _numTypesValid
```
    Bitfield that indicates which numeric representations have been calculated for the current type
  - _numberInt
```
protected int _numberInt
```
  - _numberLong
```
protected long _numberLong
```
  - _numberDouble
```
protected double _numberDouble
```
  - _numberBigInt
```
protected BigInteger _numberBigInt
```
  - _numberBigDecimal
```
protected BigDecimal _numberBigDecimal
```
  - _numberNegative
```
protected boolean _numberNegative
```
    Flag that indicates whether numeric value has a negative value. That is, whether its textual representation starts with minus character.
  - _intLength
```
protected int _intLength
```
    Length of integer part of the number, in characters
  - _fractLength
```
protected int _fractLength
```
    Length of the fractional part (not including decimal point or exponent), in characters. Not used for pure integer values.
  - _expLength
```
protected int _expLength
```
    Length of the exponent part of the number, if any, not including 'e' marker or sign, just digits. Not used for pure integer values.
- Constructor Detail
  - ParserBase
```
protected ParserBase(IOContext ctxt,
          int features)
```
- Method Detail
  - version
```
public Version version()
```
    Description copied from class: JsonParser
    
    Accessor for getting version of the core package, given a parser instance. Left for sub-classes to implement.
    
    Specified by:
    
    version in interface Versioned
    
    Specified by:
    
    version in class JsonParser
  - getCurrentValue
```
public Object getCurrentValue()
```
    Description copied from class: JsonParser
    
    Helper method, usually equivalent to: getParsingContext().getCurrentValue();
    Note that "current value" is NOT populated (or used) by Streaming parser; it is only used by higher-level data-binding functionality. The reason it is included here is that it can be stored and accessed hierarchically, and gets passed through data-binding.
    
    Overrides:
    
    getCurrentValue in class JsonParser
  - setCurrentValue
```
public void setCurrentValue(Object v)
```
    Description copied from class: JsonParser
    
    Helper method, usually equivalent to: getParsingContext().setCurrentValue(v);
    
    Overrides:
    
    setCurrentValue in class JsonParser
  - enable
```
public JsonParser enable(JsonParser.Feature f)
```
    Description copied from class: JsonParser
    
    Method for enabling specified parser feature (check JsonParser.Feature for list of features)
    
    Overrides:
    
    enable in class JsonParser
  - disable
```
public JsonParser disable(JsonParser.Feature f)
```
    Description copied from class: JsonParser
    
    Method for disabling specified feature (check JsonParser.Feature for list of features)
    
    Overrides:
    
    disable in class JsonParser
  - setFeatureMask
```
public JsonParser setFeatureMask(int newMask)
```
    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
  - getCurrentName
```
public String getCurrentName()
                      throws IOException
```
    Method that can be called to get the name associated with the current event.
    
    Specified by:
    
    getCurrentName in class ParserMinimalBase
    
    Throws:
    
    IOException
  - overrideCurrentName
```
public void overrideCurrentName(String name)
```
    Description copied from class: JsonParser
    
    Method that can be used to change what is considered to be the current (field) name. May be needed to support non-JSON data formats or unusual binding conventions; not needed for typical processing.
    Note that use of this method should only be done as sort of last resort, as it is a work-around for regular operation.
    
    Specified by:
    
    overrideCurrentName in class ParserMinimalBase
    
    Parameters:
    name - Name to use as the current name; may be null.
  - close
```
public void close()
           throws IOException
```
    Description copied from class: JsonParser
    
    Closes the parser so that no further iteration or data access can be made; will also close the underlying input source if parser either owns the input source, or feature JsonParser.Feature.AUTO_CLOSE_SOURCE is enabled. Whether parser owns the input source depends on factory method that was used to construct instance (so check JsonFactory for details, but the general idea is that if caller passes in closable resource (such as InputStream or Reader) parser does NOT own the source; but if it passes a reference (such as File or URL and creates stream or reader it does own them.
    
    Specified by:
    
    close in interface Closeable
    
    Specified by:
    
    close in interface AutoCloseable
    
    Specified by:
    
    close in class ParserMinimalBase
    
    Throws:
    
    IOException
  - isClosed
```
public boolean isClosed()
```
    Description copied from class: JsonParser
    
    Method that can be called to determine whether this parser is closed or not. If it is closed, no new tokens can be retrieved by calling JsonParser.nextToken() (and the underlying stream may be closed). Closing may be due to an explicit call to JsonParser.close() or because parser has encountered end of input.
    
    Specified by:
    
    isClosed in class ParserMinimalBase
  - getParsingContext
```
public JsonReadContext getParsingContext()
```
    Description copied from class: JsonParser
    
    Method that can be used to access current parsing context reader is in. There are 3 different types: root, array and object contexts, with slightly different available information. Contexts are hierarchically nested, and can be used for example for figuring out part of the input document that correspond to specific array or object (for highlighting purposes, or error reporting). Contexts can also be used for simple xpath-like matching of input, if so desired.
    
    Specified by:
    
    getParsingContext in class ParserMinimalBase
  - getTokenLocation
```
public JsonLocation getTokenLocation()
```
    Method that return the starting location of the current token; that is, position of the first character from input that starts the current token.
    
    Specified by:
    
    getTokenLocation in class JsonParser
  - getCurrentLocation
```
public JsonLocation getCurrentLocation()
```
    Method that returns location of the last processed character; usually for error reporting purposes
    
    Specified by:
    
    getCurrentLocation in class JsonParser
  - hasTextCharacters
```
public boolean hasTextCharacters()
```
    Description copied from class: JsonParser
    
    Method that can be used to determine whether calling of JsonParser.getTextCharacters() would be the most efficient way to access textual content for the event parser currently points to.
    Default implementation simply returns false since only actual implementation class has knowledge of its internal buffering state. Implementations are strongly encouraged to properly override this method, to allow efficient copying of content by other code.
    
    Specified by:
    
    hasTextCharacters in class ParserMinimalBase
    
    Returns:
    True if parser currently has character array that can be efficiently returned via JsonParser.getTextCharacters(); false means that it may or may not exist
  - getEmbeddedObject
```
public Object getEmbeddedObject()
                         throws IOException
```
    Description copied from class: JsonParser
    
    Accessor that can be called if (and only if) the current token is JsonToken.VALUE_EMBEDDED_OBJECT. For other token types, null is returned.
    Note: only some specialized parser implementations support embedding of objects (usually ones that are facades on top of non-streaming sources, such as object trees).
    
    Specified by:
    
    getEmbeddedObject in class JsonParser
    
    Throws:
    
    IOException
  - getTokenCharacterOffset
```
public long getTokenCharacterOffset()
```
  - getTokenLineNr
```
public int getTokenLineNr()
```
  - getTokenColumnNr
```
public int getTokenColumnNr()
```
  - loadMoreGuaranteed
```
protected final void loadMoreGuaranteed()
                                 throws IOException
```
    Throws:
    
    IOException
  - loadMore
```
protected abstract boolean loadMore()
                             throws IOException
```
    Throws:
    
    IOException
  - _finishString
```
protected abstract void _finishString()
                               throws IOException
```
    Throws:
    
    IOException
  - _closeInput
```
protected abstract void _closeInput()
                             throws IOException
```
    Throws:
    
    IOException
  - _releaseBuffers
```
protected void _releaseBuffers()
                        throws IOException
```
    Method called to release internal buffers owned by the base reader. This may be called along with _closeInput() (for example, when explicitly closing this reader instance), or separately (if need be).
    
    Throws:
    
    IOException
  - _handleEOF
```
protected void _handleEOF()
                   throws JsonParseException
```
    Method called when an EOF is encountered between tokens. If so, it may be a legitimate EOF, but only iff there is no open non-root context.
    
    Specified by:
    
    _handleEOF in class ParserMinimalBase
    
    Throws:
    
    JsonParseException
  - _eofAsNextChar
```
protected final int _eofAsNextChar()
                            throws JsonParseException
```
    Throws:
    
    JsonParseException
    Since:
    
    2.4
  - _reportMismatchedEndMarker
```
protected void _reportMismatchedEndMarker(int actCh,
                              char expCh)
                                   throws JsonParseException
```
    Throws:
    
    JsonParseException
  - _getByteArrayBuilder
```
public ByteArrayBuilder _getByteArrayBuilder()
```
  - reset
```
protected final JsonToken reset(boolean negative,
              int intLen,
              int fractLen,
              int expLen)
```
  - resetInt
```
protected final JsonToken resetInt(boolean negative,
                 int intLen)
```
  - resetFloat
```
protected final JsonToken resetFloat(boolean negative,
                   int intLen,
                   int fractLen,
                   int expLen)
```
  - resetAsNaN
```
protected final JsonToken resetAsNaN(String valueStr,
                   double value)
```
  - getNumberValue
```
public Number getNumberValue()
                      throws IOException
```
    Description copied from class: JsonParser
    
    Generic number value accessor method that will work for all kinds of numeric values. It will return the optimal (simplest/smallest possible) wrapper object that can express the numeric value just parsed.
    
    Specified by:
    
    getNumberValue in class JsonParser
    
    Throws:
    
    IOException
  - getNumberType
```
public JsonParser.NumberType getNumberType()
                                    throws IOException
```
    Description copied from class: JsonParser
    
    If current token is of type JsonToken.VALUE_NUMBER_INT or JsonToken.VALUE_NUMBER_FLOAT, returns one of JsonParser.NumberType constants; otherwise returns null.
    
    Specified by:
    
    getNumberType in class JsonParser
    
    Throws:
    
    IOException
  - getIntValue
```
public int getIntValue()
                throws IOException
```
    Description copied from class: JsonParser
    
    Numeric accessor that can be called when the current token is of type JsonToken.VALUE_NUMBER_INT and it can be expressed as a value of Java int primitive type. It can also be called for JsonToken.VALUE_NUMBER_FLOAT; if so, it is equivalent to calling JsonParser.getDoubleValue() and then casting; except for possible overflow/underflow exception.
    Note: if the resulting integer value falls outside range of Java int, a JsonParseException may be thrown to indicate numeric overflow/underflow.
    
    Specified by:
    
    getIntValue in class JsonParser
    
    Throws:
    
    IOException
  - getLongValue
```
public long getLongValue()
                  throws IOException
```
    Description copied from class: JsonParser
    
    Numeric accessor that can be called when the current token is of type JsonToken.VALUE_NUMBER_INT and it can be expressed as a Java long primitive type. It can also be called for JsonToken.VALUE_NUMBER_FLOAT; if so, it is equivalent to calling JsonParser.getDoubleValue() and then casting to int; except for possible overflow/underflow exception.
    Note: if the token is an integer, but its value falls outside of range of Java long, a JsonParseException may be thrown to indicate numeric overflow/underflow.
    
    Specified by:
    
    getLongValue in class JsonParser
    
    Throws:
    
    IOException
  - getBigIntegerValue
```
public BigInteger getBigIntegerValue()
                              throws IOException
```
    Description copied from class: JsonParser
    
    Numeric accessor that can be called when the current token is of type JsonToken.VALUE_NUMBER_INT and it can not be used as a Java long primitive type due to its magnitude. It can also be called for JsonToken.VALUE_NUMBER_FLOAT; if so, it is equivalent to calling JsonParser.getDecimalValue() and then constructing a BigInteger from that value.
    
    Specified by:
    
    getBigIntegerValue in class JsonParser
    
    Throws:
    
    IOException
  - getFloatValue
```
public float getFloatValue()
                    throws IOException
```
    Description copied from class: JsonParser
    
    Numeric accessor that can be called when the current token is of type JsonToken.VALUE_NUMBER_FLOAT and it can be expressed as a Java float primitive type. It can also be called for JsonToken.VALUE_NUMBER_INT; if so, it is equivalent to calling JsonParser.getLongValue() and then casting; except for possible overflow/underflow exception.
    Note: if the value falls outside of range of Java float, a JsonParseException will be thrown to indicate numeric overflow/underflow.
    
    Specified by:
    
    getFloatValue in class JsonParser
    
    Throws:
    
    IOException
  - getDoubleValue
```
public double getDoubleValue()
                      throws IOException
```
    Description copied from class: JsonParser
    
    Numeric accessor that can be called when the current token is of type JsonToken.VALUE_NUMBER_FLOAT and it can be expressed as a Java double primitive type. It can also be called for JsonToken.VALUE_NUMBER_INT; if so, it is equivalent to calling JsonParser.getLongValue() and then casting; except for possible overflow/underflow exception.
    Note: if the value falls outside of range of Java double, a JsonParseException will be thrown to indicate numeric overflow/underflow.
    
    Specified by:
    
    getDoubleValue in class JsonParser
    
    Throws:
    
    IOException
  - getDecimalValue
```
public BigDecimal getDecimalValue()
                           throws IOException
```
    Description copied from class: JsonParser
    
    Numeric accessor that can be called when the current token is of type JsonToken.VALUE_NUMBER_FLOAT or JsonToken.VALUE_NUMBER_INT. No under/overflow exceptions are ever thrown.
    
    Specified by:
    
    getDecimalValue in class JsonParser
    
    Throws:
    
    IOException
  - _parseNumericValue
```
protected void _parseNumericValue(int expType)
                           throws IOException
```
    Method that will parse actual numeric value out of a syntactically valid number value. Type it will parse into depends on whether it is a floating point number, as well as its magnitude: smallest legal type (of ones available) is used for efficiency.
    
    Parameters:
    expType - Numeric type that we will immediately need, if any; mostly necessary to optimize handling of floating point numbers
    
    Throws:
    
    IOException
  - _parseIntValue
```
protected int _parseIntValue()
                      throws IOException
```
    Throws:
    
    IOException
    Since:
    
    2.6
  - convertNumberToInt
```
protected void convertNumberToInt()
                           throws IOException
```
    Throws:
    
    IOException
  - convertNumberToLong
```
protected void convertNumberToLong()
                            throws IOException
```
    Throws:
    
    IOException
  - convertNumberToBigInteger
```
protected void convertNumberToBigInteger()
                                  throws IOException
```
    Throws:
    
    IOException
  - convertNumberToDouble
```
protected void convertNumberToDouble()
                              throws IOException
```
    Throws:
    
    IOException
  - convertNumberToBigDecimal
```
protected void convertNumberToBigDecimal()
                                  throws IOException
```
    Throws:
    
    IOException
  - reportUnexpectedNumberChar
```
protected void reportUnexpectedNumberChar(int ch,
                              String comment)
                                   throws JsonParseException
```
    Throws:
    
    JsonParseException
  - reportInvalidNumber
```
protected void reportInvalidNumber(String msg)
                            throws JsonParseException
```
    Throws:
    
    JsonParseException
  - reportOverflowInt
```
protected void reportOverflowInt()
                          throws IOException
```
    Throws:
    
    IOException
  - reportOverflowLong
```
protected void reportOverflowLong()
                           throws IOException
```
    Throws:
    
    IOException
  - _decodeEscaped
```
protected char _decodeEscaped()
                       throws IOException
```
    Method that sub-classes must implement to support escaped sequences in base64-encoded sections. Sub-classes that do not need base64 support can leave this as is
    
    Throws:
    
    IOException
  - _decodeBase64Escape
```
protected final int _decodeBase64Escape(Base64Variant b64variant,
                      int ch,
                      int index)
                                 throws IOException
```
    Throws:
    
    IOException
  - _decodeBase64Escape
```
protected final int _decodeBase64Escape(Base64Variant b64variant,
                      char ch,
                      int index)
                                 throws IOException
```
    Throws:
    
    IOException
  - reportInvalidBase64Char
```
protected IllegalArgumentException reportInvalidBase64Char(Base64Variant b64variant,
                                               int ch,
                                               int bindex)
                                                    throws IllegalArgumentException
```
    Throws:
    
    IllegalArgumentException
  - reportInvalidBase64Char
```
protected IllegalArgumentException reportInvalidBase64Char(Base64Variant b64variant,
                                               int ch,
                                               int bindex,
                                               String msg)
                                                    throws IllegalArgumentException
```
    Parameters:
    bindex - Relative index within base64 character unit; between 0 and 3 (as unit has exactly 4 characters)
    
    Throws:
    
    IllegalArgumentException

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

NR_UNKNOWN

NR_INT

NR_LONG

NR_BIGINT

NR_DOUBLE

NR_BIGDECIMAL

INT_0

INT_9

INT_MINUS

INT_PLUS

CHAR_NULL

_numTypesValid

_numberInt

_numberLong

_numberDouble

_numberBigInt

_numberBigDecimal

_numberNegative

_intLength

_fractLength

_expLength

Constructor Detail

ParserBase

Method Detail

version

getCurrentValue

setCurrentValue

enable

disable

setFeatureMask

getCurrentName

overrideCurrentName

close

isClosed

getParsingContext

getTokenLocation

getCurrentLocation

hasTextCharacters

getEmbeddedObject

getTokenCharacterOffset

getTokenLineNr

getTokenColumnNr

loadMoreGuaranteed

loadMore

_finishString

_closeInput

_releaseBuffers

_handleEOF

_eofAsNextChar

_reportMismatchedEndMarker

_getByteArrayBuilder