Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## com.fasterxml.jackson.core.base
Class ParserBase

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

All Implemented Interfaces:
  Versioned, Closeable

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

Author:
  Tatu Saloranta

Nested Class Summary

Nested classes/interfaces inherited from class com.fasterxml.jackson.core.JsonParser
`JsonParser.Feature, JsonParser.NumberType`

Field Summary
`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_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 com.fasterxml.jackson.core.base.ParserMinimalBase
`_currToken, _lastClearedToken, 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 com.fasterxml.jackson.core.JsonParser
`_features`

Constructor Summary
`protected` | `ParserBase(IOContext ctxt, int features)`

Method Summary
`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()`
`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)`

Methods inherited from class com.fasterxml.jackson.core.base.ParserMinimalBase
`_constructError, _decodeBase64, _getCharDesc, _handleUnrecognizedCharacterEscape, _reportBase64EOF, _reportError, _reportInvalidBase64, _reportInvalidEOF, _reportInvalidEOF, _reportInvalidEOFInValue, _reportUnexpectedChar, _throwInternal, _throwInvalidSpace, _throwUnquotedSpace, _wrapError, clearCurrentToken, getBinaryValue, getCurrentToken, getLastClearedToken, getText, getTextCharacters, getTextLength, getTextOffset, getValueAsBoolean, getValueAsDouble, getValueAsInt, getValueAsLong, hasCurrentToken, nextToken, nextValue, skipChildren, version`

Methods inherited from class com.fasterxml.jackson.core.JsonParser
`_constructError, canUseSchema, configure, disable, enable, getBinaryValue, getBooleanValue, getByteValue, getCodec, getEmbeddedObject, getInputSource, getSchema, getShortValue, getValueAsBoolean, getValueAsDouble, getValueAsInt, getValueAsLong, isEnabled, isExpectedStartArrayToken, nextBooleanValue, nextFieldName, nextIntValue, nextLongValue, nextTextValue, readValueAs, readValueAs, readValueAsTree, readValuesAs, readValuesAs, releaseBuffered, releaseBuffered, setCodec, setSchema`

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

Field Detail

### _ioContext

    protected final IOContext _ioContext

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

### _closed

    protected boolean _closed

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

### _inputPtr

    protected int _inputPtr

  Pointer to next available character in buffer

### _inputEnd

    protected int _inputEnd

  Index of character after last available one in the buffer.

### _currInputProcessed

    protected long _currInputProcessed

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

### _currInputRow

    protected int _currInputRow

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

### _currInputRowStart

    protected int _currInputRowStart

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

### _tokenInputTotal

    protected long _tokenInputTotal

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

### _tokenInputRow

    protected int _tokenInputRow

  Input row on which current token starts, 1-based

### _tokenInputCol

    protected int _tokenInputCol

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

### _parsingContext

    protected JsonReadContext _parsingContext

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

### _nextToken

    protected JsonToken _nextToken

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

### _textBuffer

    protected final TextBuffer _textBuffer

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

### _nameCopyBuffer

    protected char[] _nameCopyBuffer

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

### _nameCopied

    protected boolean _nameCopied

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

### _byteArrayBuilder

    protected ByteArrayBuilder _byteArrayBuilder

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

### _binaryValue

    protected byte[] _binaryValue

  We will hold on to decoded binary data, for duration of current event, so that multiple calls to `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_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

### ParserBase

    protected ParserBase(IOContext ctxt,
                         int features)

Method Detail

### 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 `ParserMinimalBase`
  Throws:
    `IOException`
    `JsonParseException`

### 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 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

### 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,
                                          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 `ParserMinimalBase`
  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`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2012 fasterxml.com. All Rights Reserved.