java.lang.Object
- org.codehaus.jackson.JsonParser
- - org.codehaus.jackson.impl.JsonParserMinimalBase
  - - org.codehaus.jackson.impl.JsonParserBase

All Implemented Interfaces:

Closeable, AutoCloseable, Versioned

Direct Known Subclasses:

JsonNumericParserBase, ReaderBasedParser, ReaderBasedParserBase, StreamBasedParserBase, Utf8StreamParser
```
public abstract class JsonParserBase
extends JsonParserMinimalBase
```
Intermediate base class used by all Jackson JsonParser implementations. Contains most common things that are independent of actual underlying input source

Author:

Tatu Saloranta

Nested Class Summary
- Nested classes/interfaces inherited from class org.codehaus.jackson.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 `JsonParserMinimalBase.getBinaryValue(org.codehaus.jackson.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 `JsonParserMinimalBase.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_1`
`protected static int`	`INT_2`
`protected static int`	`INT_3`
`protected static int`	`INT_4`
`protected static int`	`INT_5`
`protected static int`	`INT_6`
`protected static int`	`INT_7`
`protected static int`	`INT_8`
`protected static int`	`INT_9`
`protected static int`	`INT_DECIMAL_POINT`
`protected static int`	`INT_e`
`protected static int`	`INT_E`
`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 org.codehaus.jackson.impl.JsonParserMinimalBase
INT_APOSTROPHE, INT_ASTERISK, INT_b, INT_BACKSLASH, INT_COLON, INT_COMMA, INT_CR, INT_f, INT_LBRACKET, INT_LCURLY, INT_LF, INT_n, INT_QUOTE, INT_r, INT_RBRACKET, INT_RCURLY, INT_SLASH, INT_SPACE, INT_t, INT_TAB, INT_u

Fields inherited from class org.codehaus.jackson.JsonParser
_currToken, _features, _lastClearedToken

Constructor Summary

Constructors
Modifier Constructor Description

protected JsonParserBase(IOContext ctxt, int features)

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method	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 abstract void`	`_finishString()`
`ByteArrayBuilder`	`_getByteArrayBuilder()`
`protected void`	`_handleEOF()`	Method called when an EOF is encountered between tokens.
`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()`
`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.
`BigDecimal`	`getDecimalValue()`	Numeric accessor that can be called when the current token is of type `JsonToken.VALUE_NUMBER_FLOAT` or `JsonToken.VALUE_NUMBER_INT`.
`double`	`getDoubleValue()`	Numeric accessor that can be called when the current token is of type `JsonToken.VALUE_NUMBER_FLOAT` and it can be expressed as a Java double primitive type.
`float`	`getFloatValue()`	Numeric accessor that can be called when the current token is of type `JsonToken.VALUE_NUMBER_FLOAT` and it can be expressed as a Java float primitive type.
`int`	`getIntValue()`	Numeric accessor that can be called when the current token is of type `JsonToken.VALUE_NUMBER_INT` and it can be expressed as a value of Java int primitive type.
`long`	`getLongValue()`	Numeric accessor that can be called when the current token is of type `JsonToken.VALUE_NUMBER_INT` and it can be expressed as a Java long primitive type.
`JsonParser.NumberType`	`getNumberType()`	If current token is of type `JsonToken.VALUE_NUMBER_INT` or `JsonToken.VALUE_NUMBER_FLOAT`, returns one of `JsonParser.NumberType` constants; otherwise returns null.
`Number`	`getNumberValue()`	Generic number value accessor method that will work for all kinds of numeric values.
`JsonReadContext`	`getParsingContext()`	Method that can be used to access current parsing context reader is in.
`long`	`getTokenCharacterOffset()`
`int`	`getTokenColumnNr()`
`int`	`getTokenLineNr()`
`JsonLocation`	`getTokenLocation()`	Method that return the starting location of the current token; that is, position of the first character from input that starts the current token.
`boolean`	`hasTextCharacters()`	Method that can be used to determine whether calling of `JsonParser.getTextCharacters()` would be the most efficient way to access textual content for the event parser currently points to.
`boolean`	`isClosed()`	Method that can be called to determine whether this parser is closed or not.
`protected abstract boolean`	`loadMore()`
`protected void`	`loadMoreGuaranteed()`
`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)`
`Version`	`version()`	Method called to detect version of the component that implements this interface; returned version should never be null, but may return specific "not available" instance (see `Version` for details).

Methods inherited from class org.codehaus.jackson.impl.JsonParserMinimalBase
_constructError, _decodeBase64, _getCharDesc, _handleUnrecognizedCharacterEscape, _reportBase64EOF, _reportError, _reportInvalidBase64, _reportInvalidEOF, _reportInvalidEOF, _reportInvalidEOFInValue, _reportUnexpectedChar, _throwInternal, _throwInvalidSpace, _throwUnquotedSpace, _wrapError, getBinaryValue, getText, getTextCharacters, getTextLength, getTextOffset, getValueAsBoolean, getValueAsDouble, getValueAsInt, getValueAsLong, nextToken, skipChildren

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 JsonParserMinimalBase.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 JsonParserMinimalBase.getBinaryValue(org.codehaus.jackson.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_1
```
protected static final int INT_1
```
    See Also:
    
    Constant Field Values
  - INT_2
```
protected static final int INT_2
```
    See Also:
    
    Constant Field Values
  - INT_3
```
protected static final int INT_3
```
    See Also:
    
    Constant Field Values
  - INT_4
```
protected static final int INT_4
```
    See Also:
    
    Constant Field Values
  - INT_5
```
protected static final int INT_5
```
    See Also:
    
    Constant Field Values
  - INT_6
```
protected static final int INT_6
```
    See Also:
    
    Constant Field Values
  - INT_7
```
protected static final int INT_7
```
    See Also:
    
    Constant Field Values
  - INT_8
```
protected static final int INT_8
```
    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
  - INT_DECIMAL_POINT
```
protected static final int INT_DECIMAL_POINT
```
    See Also:
    
    Constant Field Values
  - INT_e
```
protected static final int INT_e
```
    See Also:
    
    Constant Field Values
  - INT_E
```
protected static final int INT_E
```
    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
  - JsonParserBase
```
protected JsonParserBase(IOContext ctxt,
                         int features)
```
- Method Detail
  - version
```
public Version version()
```
    Description copied from interface: Versioned
    
    Method called to detect version of the component that implements this interface; returned version should never be null, but may return specific "not available" instance (see Version for details).
    
    Specified by:
    
    version in interface Versioned
    
    Overrides:
    
    version in class JsonParser
  - getCurrentName
```
public String getCurrentName()
                      throws IOException,
                             JsonParseException
```
    Method that can be called to get the name associated with the current event.
    
    Specified by:
    
    getCurrentName in class JsonParserMinimalBase
    
    Throws:
    
    IOException
    
    JsonParseException
  - 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 AutoCloseable
    
    Specified by:
    
    close in interface Closeable
    
    Specified by:
    
    close in class JsonParserMinimalBase
    
    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 JsonParserMinimalBase
  - 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 JsonParserMinimalBase
  - 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 JsonParserMinimalBase
    
    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
  - getTokenCharacterOffset
```
public final long getTokenCharacterOffset()
```
  - getTokenLineNr
```
public final int getTokenLineNr()
```
  - getTokenColumnNr
```
public final 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,
                                      JsonParseException
```
    Throws:
    
    IOException
    
    JsonParseException
  - _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 JsonParserMinimalBase
    
    Throws:
    
    JsonParseException
  - _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,
                             JsonParseException
```
    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
    
    JsonParseException
  - getNumberType
```
public JsonParser.NumberType getNumberType()
                                    throws IOException,
                                           JsonParseException
```
    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
    
    JsonParseException
  - getIntValue
```
public int getIntValue()
                throws IOException,
                       JsonParseException
```
    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
    
    JsonParseException
  - getLongValue
```
public long getLongValue()
                  throws IOException,
                         JsonParseException
```
    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
    
    JsonParseException
  - getBigIntegerValue
```
public BigInteger getBigIntegerValue()
                              throws IOException,
                                     JsonParseException
```
    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
    
    JsonParseException
  - getFloatValue
```
public float getFloatValue()
                    throws IOException,
                           JsonParseException
```
    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
    
    JsonParseException
  - getDoubleValue
```
public double getDoubleValue()
                      throws IOException,
                             JsonParseException
```
    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
    
    JsonParseException
  - getDecimalValue
```
public BigDecimal getDecimalValue()
                           throws IOException,
                                  JsonParseException
```
    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
    
    JsonParseException
  - _parseNumericValue
```
protected void _parseNumericValue(int expType)
                           throws IOException,
                                  JsonParseException
```
    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
    
    JsonParseException
  - convertNumberToInt
```
protected void convertNumberToInt()
                           throws IOException,
                                  JsonParseException
```
    Throws:
    
    IOException
    
    JsonParseException
  - convertNumberToLong
```
protected void convertNumberToLong()
                            throws IOException,
                                   JsonParseException
```
    Throws:
    
    IOException
    
    JsonParseException
  - convertNumberToBigInteger
```
protected void convertNumberToBigInteger()
                                  throws IOException,
                                         JsonParseException
```
    Throws:
    
    IOException
    
    JsonParseException
  - convertNumberToDouble
```
protected void convertNumberToDouble()
                              throws IOException,
                                     JsonParseException
```
    Throws:
    
    IOException
    
    JsonParseException
  - convertNumberToBigDecimal
```
protected void convertNumberToBigDecimal()
                                  throws IOException,
                                         JsonParseException
```
    Throws:
    
    IOException
    
    JsonParseException
  - reportUnexpectedNumberChar
```
protected void reportUnexpectedNumberChar(int ch,
                                          String comment)
                                   throws JsonParseException
```
    Throws:
    
    JsonParseException
  - reportInvalidNumber
```
protected void reportInvalidNumber(String msg)
                            throws JsonParseException
```
    Throws:
    
    JsonParseException
  - reportOverflowInt
```
protected void reportOverflowInt()
                          throws IOException,
                                 JsonParseException
```
    Throws:
    
    IOException
    
    JsonParseException
  - reportOverflowLong
```
protected void reportOverflowLong()
                           throws IOException,
                                  JsonParseException
```
    Throws:
    
    IOException
    
    JsonParseException
  - _decodeEscaped
```
protected char _decodeEscaped()
                       throws IOException,
                              JsonParseException
```
    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
    
    JsonParseException
  - _decodeBase64Escape
```
protected final int _decodeBase64Escape(Base64Variant b64variant,
                                        int ch,
                                        int index)
                                 throws IOException,
                                        JsonParseException
```
    Throws:
    
    IOException
    
    JsonParseException
  - _decodeBase64Escape
```
protected final int _decodeBase64Escape(Base64Variant b64variant,
                                        char ch,
                                        int index)
                                 throws IOException,
                                        JsonParseException
```
    Throws:
    
    IOException
    
    JsonParseException
  - 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 JsonParserBase

Nested Class Summary

Nested classes/interfaces inherited from class org.codehaus.jackson.JsonParser

Field Summary

Fields inherited from class org.codehaus.jackson.impl.JsonParserMinimalBase

Fields inherited from class org.codehaus.jackson.JsonParser

Constructor Summary

Method Summary

Methods inherited from class org.codehaus.jackson.impl.JsonParserMinimalBase

Methods inherited from class org.codehaus.jackson.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_1

INT_2

INT_3

INT_4

INT_5

INT_6

INT_7

INT_8

INT_9

INT_MINUS

INT_PLUS

INT_DECIMAL_POINT

INT_e

INT_E

CHAR_NULL

_numTypesValid

_numberInt

_numberLong

_numberDouble

_numberBigInt

_numberBigDecimal

_numberNegative

_intLength

_fractLength

_expLength

Constructor Detail

JsonParserBase

Method Detail

version

getCurrentName

close

isClosed

getParsingContext

getTokenLocation

getCurrentLocation

hasTextCharacters

getTokenCharacterOffset

getTokenLineNr

getTokenColumnNr

loadMoreGuaranteed

loadMore

_finishString

_closeInput

_releaseBuffers