ParserBase
Date: 2016-12-03

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, java.io.Closeable, java.lang.AutoCloseable
  Direct Known Subclasses:
    ReaderBasedJsonParser, UTF8DataInputJsonParser, UTF8StreamJsonParser

      public abstract class ParserBase
      extends ParserMinimalBase

  Intermediate base class used by all Jackson `JsonParser` implementations. Contains most common things that are independent of actual underlying input source.

- - ### Nested Class Summary

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

      `JsonParser.Feature, JsonParser.NumberType`

  - ### Field Summary

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

  - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `protected` | `ParserBase(IOContext ctxt, int features)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | `_checkStdFeatureChanges(int newFeatureFlags, int changedFeatures)` Helper method called to verify changes to standard features.
    `protected abstract void` | `_closeInput()`
    `protected int` | `_decodeBase64Escape(Base64Variant b64variant, char ch, int index)`
    `protected int` | `_decodeBase64Escape(Base64Variant b64variant, int ch, int index)`
    `protected char` | `_decodeEscaped()` Method that sub-classes must implement to support escaped sequences in base64-encoded sections.
    `protected int` | `_eofAsNextChar()`
    `protected void` | `_finishString()`
    `ByteArrayBuilder` | `_getByteArrayBuilder()`
    `protected 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)
    `java.math.BigInteger` | `getBigIntegerValue()` Numeric accessor that can be called when the current token is of type `JsonToken.VALUE_NUMBER_INT` and it can not be used as a Java long primitive type due to its magnitude.
    `byte[]` | `getBinaryValue(Base64Variant variant)` Method that can be used to read (and consume -- results may not be accessible using other methods after the call) base64-encoded binary data included in the current textual JSON value.
    `JsonLocation` | `getCurrentLocation()` Method that returns location of the last processed character; usually for error reporting purposes
    `java.lang.String` | `getCurrentName()` Method that can be called to get the name associated with the current event.
    `java.lang.Object` | `getCurrentValue()` Helper method, usually equivalent to: `getParsingContext().getCurrentValue();`
    `java.math.BigDecimal` | `getDecimalValue()` Numeric accessor that can be called when the current token is of type `JsonToken.VALUE_NUMBER_FLOAT` or `JsonToken.VALUE_NUMBER_INT`.
    `double` | `getDoubleValue()` Numeric accessor that can be called when the current token is of type `JsonToken.VALUE_NUMBER_FLOAT` and it can be expressed as a Java double primitive type.
    `float` | `getFloatValue()` Numeric accessor that can be called when the current token is of type `JsonToken.VALUE_NUMBER_FLOAT` and it can be expressed as a Java float primitive type.
    `int` | `getIntValue()` Numeric accessor that can be called when the current token is of type `JsonToken.VALUE_NUMBER_INT` and it can be expressed as a value of Java int primitive type.
    `long` | `getLongValue()` Numeric accessor that can be called when the current token is of type `JsonToken.VALUE_NUMBER_INT` and it can be expressed as a Java long primitive type.
    `JsonParser.NumberType` | `getNumberType()` If current token is of type `JsonToken.VALUE_NUMBER_INT` or `JsonToken.VALUE_NUMBER_FLOAT`, returns one of `JsonParser.NumberType` constants; otherwise returns null.
    `java.lang.Number` | `getNumberValue()` Generic number value accessor method that will work for all kinds of numeric values.
    `JsonReadContext` | `getParsingContext()` Method that can be used to access current parsing context reader is in.
    `long` | `getTokenCharacterOffset()`
    `int` | `getTokenColumnNr()`
    `int` | `getTokenLineNr()`
    `JsonLocation` | `getTokenLocation()` Method that return the starting location of the current token; that is, position of the first character from input that starts the current token.
    `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 boolean` | `loadMore()` Deprecated.
    `protected void` | `loadMoreGuaranteed()` Deprecated.
    `void` | `overrideCurrentName(java.lang.String name)` Method that can be used to change what is considered to be the current (field) name.
    `JsonParser` | `overrideStdFeatures(int values, int mask)` Bulk set method for (re)setting states of features specified by `mask`.
    `protected java.lang.IllegalArgumentException` | `reportInvalidBase64Char(Base64Variant b64variant, int ch, int bindex)`
    `protected java.lang.IllegalArgumentException` | `reportInvalidBase64Char(Base64Variant b64variant, int ch, int bindex, java.lang.String msg)`
    `protected void` | `reportInvalidNumber(java.lang.String msg)`
    `protected void` | `reportOverflowInt()`
    `protected void` | `reportOverflowLong()`
    `protected void` | `reportUnexpectedNumberChar(int ch, java.lang.String comment)`
    `protected JsonToken` | `reset(boolean negative, int intLen, int fractLen, int expLen)`
    `protected JsonToken` | `resetAsNaN(java.lang.String valueStr, double value)`
    `protected JsonToken` | `resetFloat(boolean negative, int intLen, int fractLen, int expLen)`
    `protected JsonToken` | `resetInt(boolean negative, int intLen)`
    `void` | `setCurrentValue(java.lang.Object v)` Helper method, usually equivalent to: `getParsingContext().setCurrentValue(v);`
    `JsonParser` | `setFeatureMask(int newMask)` Deprecated.
    `Version` | `version()` Accessor for getting version of the core package, given a parser instance.

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

      `_ascii, _asciiBytes, _constructError, _decodeBase64, _getCharDesc, _handleUnrecognizedCharacterEscape, _hasTextualNull, _reportError, _reportInvalidEOF, _reportInvalidEOF, _reportInvalidEOF, _reportInvalidEOFInValue, _reportInvalidEOFInValue, _reportMissingRootWS, _reportUnexpectedChar, _throwInternal, _throwInvalidSpace, _throwUnquotedSpace, _wrapError, clearCurrentToken, currentToken, currentTokenId, getCurrentToken, getCurrentTokenId, getLastClearedToken, getText, getTextCharacters, getTextLength, getTextOffset, getValueAsBoolean, getValueAsDouble, getValueAsInt, getValueAsInt, getValueAsLong, getValueAsLong, getValueAsString, getValueAsString, hasCurrentToken, hasToken, hasTokenId, isExpectedStartArrayToken, isExpectedStartObjectToken, nextToken, nextValue, skipChildren`

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

      `_codec, _constructError, _reportUnsupportedOperation, canReadObjectId, canReadTypeId, canUseSchema, configure, finishToken, getBinaryValue, getBooleanValue, getByteValue, getCodec, getEmbeddedObject, getFeatureMask, getFormatFeatures, getInputSource, getObjectId, getSchema, getShortValue, getText, getTypeId, getValueAsBoolean, getValueAsDouble, isEnabled, nextBooleanValue, nextFieldName, nextFieldName, nextIntValue, nextLongValue, nextTextValue, overrideFormatFeatures, readBinaryValue, readBinaryValue, readValueAs, readValueAs, readValueAsTree, readValuesAs, readValuesAs, releaseBuffered, releaseBuffered, requiresCustomCodec, setCodec, setRequestPayloadOnError, setRequestPayloadOnError, setRequestPayloadOnError, setSchema`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### _ioContext

          protected final IOContext _ioContext

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

    - #### _closed

          protected boolean _closed

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

    - #### _inputPtr

          protected int _inputPtr

      Pointer to next available character in buffer

    - #### _inputEnd

          protected int _inputEnd

      Index of character after last available one in the buffer.

    - #### _currInputProcessed

          protected long _currInputProcessed

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

    - #### _currInputRow

          protected int _currInputRow

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

    - #### _currInputRowStart

          protected int _currInputRowStart

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

    - #### _tokenInputTotal

          protected long _tokenInputTotal

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

    - #### _tokenInputRow

          protected int _tokenInputRow

      Input row on which current token starts, 1-based

    - #### _tokenInputCol

          protected int _tokenInputCol

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

    - #### _parsingContext

          protected JsonReadContext _parsingContext

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

    - #### _nextToken

          protected JsonToken _nextToken

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

    - #### _textBuffer

          protected final TextBuffer _textBuffer

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

    - #### _nameCopyBuffer

          protected char[] _nameCopyBuffer

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

    - #### _nameCopied

          protected boolean _nameCopied

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

    - #### _byteArrayBuilder

          protected ByteArrayBuilder _byteArrayBuilder

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

    - #### _binaryValue

          protected byte[] _binaryValue

      We will hold on to decoded binary data, for duration of current event, so that multiple calls to `getBinaryValue(com.fasterxml.jackson.core.Base64Variant)` will not need to decode data more than once.

    - #### 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 java.math.BigInteger _numberBigInt

    - #### _numberBigDecimal

          protected java.math.BigDecimal _numberBigDecimal

    - #### _numberNegative

          protected boolean _numberNegative

      Flag that indicates whether numeric value has a negative value. That is, whether its textual representation starts with minus character.

    - #### _intLength

          protected int _intLength

      Length of integer part of the number, in characters

    - #### _fractLength

          protected int _fractLength

      Length of the fractional part (not including decimal point or exponent), in characters. Not used for pure integer values.

    - #### _expLength

          protected int _expLength

      Length of the exponent part of the number, if any, not including 'e' marker or sign, just digits. Not used for pure integer values.

  - ### Constructor Detail

    - #### ParserBase

          protected ParserBase(IOContext ctxt,
                    int features)

  - ### Method Detail

    - #### version

          public Version version()

      Description copied from class: `JsonParser`
      Accessor for getting version of the core package, given a parser instance. Left for sub-classes to implement.
      Specified by:
        `version` in interface `Versioned`
      Specified by:
        `version` in class `JsonParser`

    - #### getCurrentValue

          public java.lang.Object getCurrentValue()

      Description copied from class: `JsonParser`
      Helper method, usually equivalent to: `getParsingContext().getCurrentValue();`

      Note that "current value" is NOT populated (or used) by Streaming parser; it is only used by higher-level data-binding functionality. The reason it is included here is that it can be stored and accessed hierarchically, and gets passed through data-binding.

      Overrides:
        `getCurrentValue` in class `JsonParser`

    - #### setCurrentValue

          public void setCurrentValue(java.lang.Object v)

      Description copied from class: `JsonParser`
      Helper method, usually equivalent to: `getParsingContext().setCurrentValue(v);`
      Overrides:
        `setCurrentValue` in class `JsonParser`

    - #### enable

          public JsonParser enable(JsonParser.Feature f)

      Description copied from class: `JsonParser`
      Method for enabling specified parser feature (check `JsonParser.Feature` for list of features)
      Overrides:
        `enable` in class `JsonParser`

    - #### disable

          public JsonParser disable(JsonParser.Feature f)

      Description copied from class: `JsonParser`
      Method for disabling specified feature (check `JsonParser.Feature` for list of features)
      Overrides:
        `disable` in class `JsonParser`

    - #### setFeatureMask

          @Deprecated
          public JsonParser setFeatureMask(int newMask)

      Deprecated.
      Description copied from class: `JsonParser`
      Bulk set method for (re)setting states of all standard `JsonParser.Feature`s
      Overrides:
        `setFeatureMask` in class `JsonParser`
      Returns:
        This parser object, to allow chaining of calls

    - #### overrideStdFeatures

          public JsonParser overrideStdFeatures(int values,
                                       int mask)

      Description copied from class: `JsonParser`
      Bulk set method for (re)setting states of features specified by `mask`. Functionally equivalent to `int oldState = getFeatureMask(); int newState = (oldState & ~mask) | (values & mask); setFeatureMask(newState);` but preferred as this lets caller more efficiently specify actual changes made.
      Overrides:
        `overrideStdFeatures` in class `JsonParser`
      Parameters:
        `values` - Bit mask of set/clear state for features to change
        `mask` - Bit mask of features to change

    - #### _checkStdFeatureChanges

          protected void _checkStdFeatureChanges(int newFeatureFlags,
                                     int changedFeatures)

      Helper method called to verify changes to standard features.
      Parameters:
        `newFeatureFlags` - Bitflag of standard features after they were changed
        `changedFeatures` - Bitflag of standard features for which setting did change
      Since:
        2.7

    - #### getCurrentName

          public java.lang.String getCurrentName()
                                          throws java.io.IOException

      Method that can be called to get the name associated with the current event.
      Specified by:
        `getCurrentName` in class `ParserMinimalBase`
      Throws:
        `java.io.IOException`

    - #### overrideCurrentName

          public void overrideCurrentName(java.lang.String name)

      Description copied from class: `JsonParser`
      Method that can be used to change what is considered to be the current (field) name. May be needed to support non-JSON data formats or unusual binding conventions; not needed for typical processing.

      Note that use of this method should only be done as sort of last resort, as it is a work-around for regular operation.

      Specified by:
        `overrideCurrentName` in class `ParserMinimalBase`
      Parameters:
        `name` - Name to use as the current name; may be null.

    - #### close

          public void close()
                     throws java.io.IOException

      Description copied from class: `JsonParser`
      Closes the parser so that no further iteration or data access can be made; will also close the underlying input source if parser either owns the input source, or feature `JsonParser.Feature.AUTO_CLOSE_SOURCE` is enabled. Whether parser owns the input source depends on factory method that was used to construct instance (so check `JsonFactory` for details, but the general idea is that if caller passes in closable resource (such as `InputStream` or `Reader`) parser does NOT own the source; but if it passes a reference (such as `File` or `URL` and creates stream or reader it does own them.
      Specified by:
        `close` in interface `java.io.Closeable`
      Specified by:
        `close` in interface `java.lang.AutoCloseable`
      Specified by:
        `close` in class `ParserMinimalBase`
      Throws:
        `java.io.IOException`

    - #### isClosed

          public boolean isClosed()

      Description copied from class: `JsonParser`
      Method that can be called to determine whether this parser is closed or not. If it is closed, no new tokens can be retrieved by calling `JsonParser.nextToken()` (and the underlying stream may be closed). Closing may be due to an explicit call to `JsonParser.close()` or because parser has encountered end of input.
      Specified by:
        `isClosed` in class `ParserMinimalBase`

    - #### getParsingContext

          public JsonReadContext getParsingContext()

      Description copied from class: `JsonParser`
      Method that can be used to access current parsing context reader is in. There are 3 different types: root, array and object contexts, with slightly different available information. Contexts are hierarchically nested, and can be used for example for figuring out part of the input document that correspond to specific array or object (for highlighting purposes, or error reporting). Contexts can also be used for simple xpath-like matching of input, if so desired.
      Specified by:
        `getParsingContext` in class `ParserMinimalBase`

    - #### getTokenLocation

          public JsonLocation getTokenLocation()

      Method that return the starting location of the current token; that is, position of the first character from input that starts the current token.
      Specified by:
        `getTokenLocation` in class `JsonParser`

    - #### getCurrentLocation

          public JsonLocation getCurrentLocation()

      Method that returns location of the last processed character; usually for error reporting purposes
      Specified by:
        `getCurrentLocation` in class `JsonParser`

    - #### hasTextCharacters

          public boolean hasTextCharacters()

      Description copied from class: `JsonParser`
      Method that can be used to determine whether calling of `JsonParser.getTextCharacters()` would be the most efficient way to access textual content for the event parser currently points to.

      Default implementation simply returns false since only actual implementation class has knowledge of its internal buffering state. Implementations are strongly encouraged to properly override this method, to allow efficient copying of content by other code.

      Specified by:
        `hasTextCharacters` in class `ParserMinimalBase`
      Returns:
        True if parser currently has character array that can be efficiently returned via `JsonParser.getTextCharacters()`; false means that it may or may not exist

    - #### getBinaryValue

          public byte[] getBinaryValue(Base64Variant variant)
                                throws java.io.IOException

      Description copied from class: `JsonParser`
      Method that can be used to read (and consume -- results may not be accessible using other methods after the call) base64-encoded binary data included in the current textual JSON value. It works similar to getting String value via `JsonParser.getText()` and decoding result (except for decoding part), but should be significantly more performant.

      Note that non-decoded textual contents of the current token are not guaranteed to be accessible after this method is called. Current implementation, for example, clears up textual content during decoding. Decoded binary content, however, will be retained until parser is advanced to the next event.

      Specified by:
        `getBinaryValue` in class `ParserMinimalBase`
      Parameters:
        `variant` - Expected variant of base64 encoded content (see `Base64Variants` for definitions of "standard" variants).
      Returns:
        Decoded binary data
      Throws:
        `java.io.IOException`

    - #### getTokenCharacterOffset

          public long getTokenCharacterOffset()

    - #### getTokenLineNr

          public int getTokenLineNr()

    - #### getTokenColumnNr

          public int getTokenColumnNr()

    - #### _closeInput

          protected abstract void _closeInput()
                                       throws java.io.IOException

      Throws:
        `java.io.IOException`

    - #### _releaseBuffers

          protected void _releaseBuffers()
                                  throws java.io.IOException

      Method called to release internal buffers owned by the base reader. This may be called along with `_closeInput()` (for example, when explicitly closing this reader instance), or separately (if need be).
      Throws:
        `java.io.IOException`

    - #### _handleEOF

          protected void _handleEOF()
                             throws JsonParseException

      Method called when an EOF is encountered between tokens. If so, it may be a legitimate EOF, but only iff there is no open non-root context.
      Specified by:
        `_handleEOF` in class `ParserMinimalBase`
      Throws:
        `JsonParseException`

    - #### _eofAsNextChar

          protected final int _eofAsNextChar()
                                      throws JsonParseException

      Throws:
        `JsonParseException`
      Since:
        2.4

    - #### _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(java.lang.String valueStr,
                             double value)

    - #### getNumberValue

          public java.lang.Number getNumberValue()
                                          throws java.io.IOException

      Description copied from class: `JsonParser`
      Generic number value accessor method that will work for all kinds of numeric values. It will return the optimal (simplest/smallest possible) wrapper object that can express the numeric value just parsed.
      Specified by:
        `getNumberValue` in class `JsonParser`
      Throws:
        `java.io.IOException`

    - #### getNumberType

          public JsonParser.NumberType getNumberType()
                                              throws java.io.IOException

      Description copied from class: `JsonParser`
      If current token is of type `JsonToken.VALUE_NUMBER_INT` or `JsonToken.VALUE_NUMBER_FLOAT`, returns one of `JsonParser.NumberType` constants; otherwise returns null.
      Specified by:
        `getNumberType` in class `JsonParser`
      Throws:
        `java.io.IOException`

    - #### getIntValue

          public int getIntValue()
                          throws java.io.IOException

      Description copied from class: `JsonParser`
      Numeric accessor that can be called when the current token is of type `JsonToken.VALUE_NUMBER_INT` and it can be expressed as a value of Java int primitive type. It can also be called for `JsonToken.VALUE_NUMBER_FLOAT`; if so, it is equivalent to calling `JsonParser.getDoubleValue()` and then casting; except for possible overflow/underflow exception.

      Note: if the resulting integer value falls outside range of Java int, a `JsonParseException` may be thrown to indicate numeric overflow/underflow.

      Specified by:
        `getIntValue` in class `JsonParser`
      Throws:
        `java.io.IOException`

    - #### getLongValue

          public long getLongValue()
                            throws java.io.IOException

      Description copied from class: `JsonParser`
      Numeric accessor that can be called when the current token is of type `JsonToken.VALUE_NUMBER_INT` and it can be expressed as a Java long primitive type. It can also be called for `JsonToken.VALUE_NUMBER_FLOAT`; if so, it is equivalent to calling `JsonParser.getDoubleValue()` and then casting to int; except for possible overflow/underflow exception.

      Note: if the token is an integer, but its value falls outside of range of Java long, a `JsonParseException` may be thrown to indicate numeric overflow/underflow.

      Specified by:
        `getLongValue` in class `JsonParser`
      Throws:
        `java.io.IOException`

    - #### getBigIntegerValue

          public java.math.BigInteger getBigIntegerValue()
                                                  throws java.io.IOException

      Description copied from class: `JsonParser`
      Numeric accessor that can be called when the current token is of type `JsonToken.VALUE_NUMBER_INT` and it can not be used as a Java long primitive type due to its magnitude. It can also be called for `JsonToken.VALUE_NUMBER_FLOAT`; if so, it is equivalent to calling `JsonParser.getDecimalValue()` and then constructing a `BigInteger` from that value.
      Specified by:
        `getBigIntegerValue` in class `JsonParser`
      Throws:
        `java.io.IOException`

    - #### getFloatValue

          public float getFloatValue()
                              throws java.io.IOException

      Description copied from class: `JsonParser`
      Numeric accessor that can be called when the current token is of type `JsonToken.VALUE_NUMBER_FLOAT` and it can be expressed as a Java float primitive type. It can also be called for `JsonToken.VALUE_NUMBER_INT`; if so, it is equivalent to calling `JsonParser.getLongValue()` and then casting; except for possible overflow/underflow exception.

      Note: if the value falls outside of range of Java float, a `JsonParseException` will be thrown to indicate numeric overflow/underflow.

      Specified by:
        `getFloatValue` in class `JsonParser`
      Throws:
        `java.io.IOException`

    - #### getDoubleValue

          public double getDoubleValue()
                                throws java.io.IOException

      Description copied from class: `JsonParser`
      Numeric accessor that can be called when the current token is of type `JsonToken.VALUE_NUMBER_FLOAT` and it can be expressed as a Java double primitive type. It can also be called for `JsonToken.VALUE_NUMBER_INT`; if so, it is equivalent to calling `JsonParser.getLongValue()` and then casting; except for possible overflow/underflow exception.

      Note: if the value falls outside of range of Java double, a `JsonParseException` will be thrown to indicate numeric overflow/underflow.

      Specified by:
        `getDoubleValue` in class `JsonParser`
      Throws:
        `java.io.IOException`

    - #### getDecimalValue

          public java.math.BigDecimal getDecimalValue()
                                               throws java.io.IOException

      Description copied from class: `JsonParser`
      Numeric accessor that can be called when the current token is of type `JsonToken.VALUE_NUMBER_FLOAT` or `JsonToken.VALUE_NUMBER_INT`. No under/overflow exceptions are ever thrown.
      Specified by:
        `getDecimalValue` in class `JsonParser`
      Throws:
        `java.io.IOException`

    - #### _parseNumericValue

          protected void _parseNumericValue(int expType)
                                     throws java.io.IOException

      Method that will parse actual numeric value out of a syntactically valid number value. Type it will parse into depends on whether it is a floating point number, as well as its magnitude: smallest legal type (of ones available) is used for efficiency.
      Parameters:
        `expType` - Numeric type that we will immediately need, if any; mostly necessary to optimize handling of floating point numbers
      Throws:
        `java.io.IOException`

    - #### _parseIntValue

          protected int _parseIntValue()
                                throws java.io.IOException

      Throws:
        `java.io.IOException`
      Since:
        2.6

    - #### convertNumberToInt

          protected void convertNumberToInt()
                                     throws java.io.IOException

      Throws:
        `java.io.IOException`

    - #### convertNumberToLong

          protected void convertNumberToLong()
                                      throws java.io.IOException

      Throws:
        `java.io.IOException`

    - #### convertNumberToBigInteger

          protected void convertNumberToBigInteger()
                                            throws java.io.IOException

      Throws:
        `java.io.IOException`

    - #### convertNumberToDouble

          protected void convertNumberToDouble()
                                        throws java.io.IOException

      Throws:
        `java.io.IOException`

    - #### convertNumberToBigDecimal

          protected void convertNumberToBigDecimal()
                                            throws java.io.IOException

      Throws:
        `java.io.IOException`

    - #### reportUnexpectedNumberChar

          protected void reportUnexpectedNumberChar(int ch,
                                        java.lang.String comment)
                                             throws JsonParseException

      Throws:
        `JsonParseException`

    - #### reportInvalidNumber

          protected void reportInvalidNumber(java.lang.String msg)
                                      throws JsonParseException

      Throws:
        `JsonParseException`

    - #### reportOverflowInt

          protected void reportOverflowInt()
                                    throws java.io.IOException

      Throws:
        `java.io.IOException`

    - #### reportOverflowLong

          protected void reportOverflowLong()
                                     throws java.io.IOException

      Throws:
        `java.io.IOException`

    - #### _decodeEscaped

          protected char _decodeEscaped()
                                 throws java.io.IOException

      Method that sub-classes must implement to support escaped sequences in base64-encoded sections. Sub-classes that do not need base64 support can leave this as is
      Throws:
        `java.io.IOException`

    - #### _decodeBase64Escape

          protected final int _decodeBase64Escape(Base64Variant b64variant,
                                int ch,
                                int index)
                                           throws java.io.IOException

      Throws:
        `java.io.IOException`

    - #### _decodeBase64Escape

          protected final int _decodeBase64Escape(Base64Variant b64variant,
                                char ch,
                                int index)
                                           throws java.io.IOException

      Throws:
        `java.io.IOException`

    - #### reportInvalidBase64Char

          protected java.lang.IllegalArgumentException reportInvalidBase64Char(Base64Variant b64variant,
                                                                   int ch,
                                                                   int bindex)
                                                                        throws java.lang.IllegalArgumentException

      Throws:
        `java.lang.IllegalArgumentException`

    - #### reportInvalidBase64Char

          protected java.lang.IllegalArgumentException reportInvalidBase64Char(Base64Variant b64variant,
                                                                   int ch,
                                                                   int bindex,
                                                                   java.lang.String msg)
                                                                        throws java.lang.IllegalArgumentException

      Parameters:
        `bindex` - Relative index within base64 character unit; between 0 and 3 (as unit has exactly 4 characters)
      Throws:
        `java.lang.IllegalArgumentException`

    - #### loadMoreGuaranteed

          @Deprecated
          protected void loadMoreGuaranteed()
                                     throws java.io.IOException

      Deprecated.
      Throws:
        `java.io.IOException`

    - #### loadMore

          @Deprecated
          protected boolean loadMore()
                              throws java.io.IOException

      Deprecated.
      Throws:
        `java.io.IOException`

    - #### _finishString

          protected void _finishString()
                                throws java.io.IOException

      Throws:
        `java.io.IOException`