com.fasterxml.aalto.async

## Class AsyncByteBufferScanner

- java.lang.Object
- - com.fasterxml.aalto.in.XmlScanner
  - - com.fasterxml.aalto.in.ByteBasedScanner
    - - com.fasterxml.aalto.async.AsyncByteScanner
      - - com.fasterxml.aalto.async.AsyncByteBufferScanner

- All Implemented Interfaces:
    AsyncByteBufferFeeder, AsyncInputFeeder, XmlConsts, NamespaceContext, XMLStreamConstants

      public class AsyncByteBufferScanner
      extends AsyncByteScanner
      implements AsyncByteBufferFeeder

  This is the base class for asynchronous (non-blocking) XML scanners. Due to basic complexity of async approach, character-based doesn't make much sense, so only byte-based input is supported.

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected ByteBuffer` | `_inputBuffer` This buffer is actually provided by caller
    `protected int` | `_origBufferLen` In addition to current buffer pointer, and end pointer, we will also need to know number of bytes originally contained.

    - ### Fields inherited from class com.fasterxml.aalto.async.AsyncByteScanner

      `_currQuad, _currQuadBytes, _elemAllNsBound, _elemAttrCount, _elemAttrName, _elemAttrPtr, _elemAttrQuote, _elemNsPtr, _endOfInput, _entityValue, _inDtdDeclaration, _nextEvent, _pendingInput, _quadCount, _state, _surroundingEvent, EVENT_INCOMPLETE, PENDING_STATE_ATTR_VALUE_AMP, PENDING_STATE_ATTR_VALUE_AMP_HASH, PENDING_STATE_ATTR_VALUE_AMP_HASH_X, PENDING_STATE_ATTR_VALUE_DEC_DIGIT, PENDING_STATE_ATTR_VALUE_ENTITY_NAME, PENDING_STATE_ATTR_VALUE_HEX_DIGIT, PENDING_STATE_CDATA_BRACKET1, PENDING_STATE_CDATA_BRACKET2, PENDING_STATE_COMMENT_HYPHEN1, PENDING_STATE_COMMENT_HYPHEN2, PENDING_STATE_CR, PENDING_STATE_ENT_IN_DEC_DIGIT, PENDING_STATE_ENT_IN_HEX_DIGIT, PENDING_STATE_ENT_SEEN_HASH, PENDING_STATE_ENT_SEEN_HASH_X, PENDING_STATE_PI_QMARK, PENDING_STATE_TEXT_AMP, PENDING_STATE_TEXT_AMP_HASH, PENDING_STATE_TEXT_BRACKET1, PENDING_STATE_TEXT_BRACKET2, PENDING_STATE_TEXT_DEC_ENTITY, PENDING_STATE_TEXT_HEX_ENTITY, PENDING_STATE_TEXT_IN_ENTITY, PENDING_STATE_XMLDECL_LT, PENDING_STATE_XMLDECL_LTQ, PENDING_STATE_XMLDECL_TARGET, STATE_CDATA_C, STATE_CDATA_CD, STATE_CDATA_CDA, STATE_CDATA_CDAT, STATE_CDATA_CDATA, STATE_CDATA_CONTENT, STATE_COMMENT_CONTENT, STATE_COMMENT_HYPHEN, STATE_COMMENT_HYPHEN2, STATE_DEFAULT, STATE_DTD_AFTER_DOCTYPE, STATE_DTD_AFTER_PUBLIC, STATE_DTD_AFTER_PUBLIC_ID, STATE_DTD_AFTER_ROOT_NAME, STATE_DTD_AFTER_SYSTEM, STATE_DTD_AFTER_SYSTEM_ID, STATE_DTD_BEFORE_IDS, STATE_DTD_BEFORE_PUBLIC_ID, STATE_DTD_BEFORE_ROOT_NAME, STATE_DTD_BEFORE_SYSTEM_ID, STATE_DTD_DOCTYPE, STATE_DTD_EXPECT_CLOSING_GT, STATE_DTD_INT_SUBSET, STATE_DTD_PUBLIC_ID, STATE_DTD_PUBLIC_OR_SYSTEM, STATE_DTD_ROOT_NAME, STATE_DTD_SYSTEM_ID, STATE_EE_NEED_GT, STATE_PI_AFTER_TARGET, STATE_PI_AFTER_TARGET_QMARK, STATE_PI_AFTER_TARGET_WS, STATE_PI_IN_DATA, STATE_PI_IN_TARGET, STATE_PROLOG_DECL, STATE_PROLOG_INITIAL, STATE_PROLOG_SEEN_LT, STATE_SE_ATTR_NAME, STATE_SE_ATTR_VALUE_NORMAL, STATE_SE_ATTR_VALUE_NSDECL, STATE_SE_ELEM_NAME, STATE_SE_SEEN_SLASH, STATE_SE_SPACE_OR_ATTRNAME, STATE_SE_SPACE_OR_ATTRVALUE, STATE_SE_SPACE_OR_END, STATE_SE_SPACE_OR_EQ, STATE_TEXT_AMP, STATE_TEXT_AMP_NAME, STATE_TREE_NAMED_ENTITY_START, STATE_TREE_NUMERIC_ENTITY_START, STATE_TREE_SEEN_AMP, STATE_TREE_SEEN_EXCL, STATE_TREE_SEEN_LT, STATE_TREE_SEEN_SLASH, STATE_XMLDECL_AFTER_ENCODING, STATE_XMLDECL_AFTER_ENCODING_VALUE, STATE_XMLDECL_AFTER_STANDALONE, STATE_XMLDECL_AFTER_STANDALONE_VALUE, STATE_XMLDECL_AFTER_VERSION, STATE_XMLDECL_AFTER_VERSION_VALUE, STATE_XMLDECL_AFTER_XML, STATE_XMLDECL_BEFORE_ENCODING, STATE_XMLDECL_BEFORE_STANDALONE, STATE_XMLDECL_BEFORE_VERSION, STATE_XMLDECL_ENCODING, STATE_XMLDECL_ENCODING_EQ, STATE_XMLDECL_ENCODING_VALUE, STATE_XMLDECL_ENDQ, STATE_XMLDECL_STANDALONE, STATE_XMLDECL_STANDALONE_EQ, STATE_XMLDECL_STANDALONE_VALUE, STATE_XMLDECL_VERSION, STATE_XMLDECL_VERSION_EQ, STATE_XMLDECL_VERSION_VALUE`

    - ### Fields inherited from class com.fasterxml.aalto.in.ByteBasedScanner

      `_charTypes, _inputEnd, _inputPtr, _quadBuffer, _symbols, _tmpChar, BYTE_a, BYTE_A, BYTE_AMP, BYTE_APOS, BYTE_C, BYTE_CR, BYTE_D, BYTE_EQ, BYTE_EXCL, BYTE_g, BYTE_GT, BYTE_HASH, BYTE_HYPHEN, BYTE_l, BYTE_LBRACKET, BYTE_LF, BYTE_LT, BYTE_m, BYTE_NULL, BYTE_o, BYTE_p, BYTE_P, BYTE_q, BYTE_QMARK, BYTE_QUOT, BYTE_RBRACKET, BYTE_s, BYTE_S, BYTE_SEMICOLON, BYTE_SLASH, BYTE_SPACE, BYTE_t, BYTE_T, BYTE_TAB, BYTE_u, BYTE_x`

    - ### Fields inherited from class com.fasterxml.aalto.in.XmlScanner

      `_attrCollector, _attrCount, _cfgCoalescing, _cfgLazyParsing, _config, _currElem, _currNsCount, _currRow, _currToken, _defaultNs, _depth, _entityPending, _isEmptyTag, _lastNsContext, _lastNsDecl, _nameBuffer, _nsBindingCache, _nsBindingCount, _nsBindings, _nsBindMisses, _pastBytesOrChars, _publicId, _rowStartOffset, _startColumn, _startRawOffset, _startRow, _systemId, _textBuilder, _tokenIncomplete, _tokenName, _xml11, CDATA_STR, INT_0, INT_9, INT_a, INT_A, INT_AMP, INT_APOS, INT_COLON, INT_CR, INT_EQ, INT_EXCL, INT_f, INT_F, INT_GT, INT_HYPHEN, INT_LBRACKET, INT_LF, INT_LT, INT_NULL, INT_QMARK, INT_QUOTE, INT_RBRACKET, INT_SLASH, INT_SPACE, INT_TAB, INT_z, MAX_UNICODE_CHAR, TOKEN_EOI`

    - ### Fields inherited from interface com.fasterxml.aalto.util.XmlConsts

      `CHAR_CR, CHAR_LF, CHAR_NULL, CHAR_SPACE, STAX_DEFAULT_OUTPUT_ENCODING, STAX_DEFAULT_OUTPUT_VERSION, XML_DECL_KW_ENCODING, XML_DECL_KW_STANDALONE, XML_DECL_KW_VERSION, XML_SA_NO, XML_SA_YES, XML_V_10, XML_V_10_STR, XML_V_11, XML_V_11_STR, XML_V_UNKNOWN`

    - ### Fields inherited from interface javax.xml.stream.XMLStreamConstants

      `ATTRIBUTE, CDATA, CHARACTERS, COMMENT, DTD, END_DOCUMENT, END_ELEMENT, ENTITY_DECLARATION, ENTITY_REFERENCE, NAMESPACE, NOTATION_DECLARATION, PROCESSING_INSTRUCTION, SPACE, START_DOCUMENT, START_ELEMENT`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `AsyncByteBufferScanner(ReaderConfig cfg)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected boolean` | `decodeDecEntity()`
    `protected int` | `decodeGeneralEntity(PName entityName)` Method that verifies that given named entity is followed by a semi-colon (meaning next byte must be available for reading); and if so, whether it is one of pre-defined general entities.
    `protected boolean` | `decodeHexEntity()`
    `protected int` | `decodeUtf8_2(int c)` Note: caller must guarantee enough data is available before calling the method
    `protected int` | `decodeUtf8_3(int c1)` Note: caller must guarantee enough data is available before calling the method
    `protected int` | `decodeUtf8_3(int c1, int c2, int c3)`
    `protected int` | `decodeUtf8_4(int c)`
    `protected int` | `decodeUtf8_4(int c1, int c2, int c3, int c4)`
    `void` | `feedInput(ByteBuffer buffer)` Method that can be called to feed more data, if (and only if) `AsyncInputFeeder.needMoreInput()` returns true.
    `protected void` | `finishCharacters()` This method only gets called in non-coalescing mode; and if so, needs to parse as many characters of the current text segment from the current input block as possible.
    `protected int` | `finishCharactersCoalescing()` TODO: Method not yet implemented
    `protected boolean` | `handleAttrValue()`
    `protected int` | `handleCDataPending()`
    `protected int` | `handleCommentPending()`
    `protected int` | `handleDecEntityInCharacters(int ptr)`
    `protected boolean` | `handleDTDInternalSubset(boolean init)`
    `protected int` | `handleEntityInAttributeValue()` Method called to handle entity encountered inside attribute value.
    `protected int` | `handleEntityInCharacters()` Method called to handle entity encountered inside CHARACTERS segment, when trying to complete a non-coalescing text segment.
    `protected int` | `handleEntityStartingToken()` Method called when a new token (within tree) starts with an entity.
    `protected int` | `handleHexEntityInCharacters(int ptr)`
    `protected int` | `handleNamedEntityStartingToken()` Method called when we see an entity that is starting a new token, and part of its name has been decoded (but not all)
    `protected boolean` | `handleNsDecl()`
    `protected int` | `handleNumericEntityStartingToken()` Method called to handle cases where we find something other than a character entity (or one of 4 pre-defined general entities that act like character entities)
    `protected boolean` | `handlePartialCR()` Method called when there is a pending \r (from past buffer), and we need to see
    `protected int` | `handlePIPending()`
    `protected int` | `handleStartElement()`
    `protected int` | `handleStartElementStart(byte b)` Method called when '<' and (what appears to be) a name start character have been seen.
    `boolean` | `needMoreInput()` Method called to check whether it is ok to feed more data: parser returns true if it has no more content to parse (and it is ok to feed more); otherwise false (and no data should yet be fed).
    `int` | `nextFromProlog(boolean isProlog)`
    `int` | `nextFromTree()`
    `protected int` | `parseCDataContents()`
    `protected int` | `parseCommentContents()`
    `protected PName` | `parseEntityName()`
    `protected PName` | `parseNewEntityName(byte b)`
    `protected PName` | `parseNewName(byte b)`
    `protected int` | `parsePIData()`
    `protected PName` | `parsePName()` This method can (for now?) be shared between all Ascii-based encodings, since it only does coarse validity checking -- real checks are done in different method.
    `protected boolean` | `skipCharacters()` Method that will be called to skip all possible characters from the input buffer, but without blocking.
    `protected boolean` | `skipCoalescedText()` Coalescing mode is (and will) not be implemented for non-blocking parsers, so this method should never get called.
    `protected void` | `skipUtf8_2(int c)`
    `protected int` | `startCharacters(byte b)` Method called to initialize state for CHARACTERS event, after just a single byte has been seen.
    `protected int` | `startCharactersPending()` This method gets called, if the first character of a CHARACTERS event could not be fully read (multi-byte, split over buffer boundary).
    `String` | `toString()`

    - ### Methods inherited from class com.fasterxml.aalto.async.AsyncByteScanner

      `_closeSource, checkPITargetName, decodeCharForError, endOfInput, findPName, finishCData, finishComment, finishDTD, finishPI, finishSpace, finishToken, loadMore, reportInvalidOther, skipCData, skipComment, skipPI, skipSpace, throwInternal, validPublicIdChar, verifyAndAppendEntityCharacter, verifyAndSetPublicId, verifyAndSetSystemId, verifyAndSetXmlEncoding, verifyAndSetXmlStandalone, verifyAndSetXmlVersion`

    - ### Methods inherited from class com.fasterxml.aalto.in.ByteBasedScanner

      `_releaseBuffers, addPName, addUtfPName, getCurrentColumnNr, getCurrentLocation, getEndingByteOffset, getEndingCharOffset, getStartingByteOffset, getStartingCharOffset, markLF, markLF, reportInvalidInitial, reportInvalidOther, setStartLocation`

    - ### Methods inherited from class com.fasterxml.aalto.in.XmlScanner

      `bindName, bindNs, checkImmutableBinding, close, decodeAttrBinaryValue, decodeAttrValue, decodeAttrValues, decodeElements, findAttrIndex, findOrCreateBinding, fireSaxCharacterEvents, fireSaxCommentEvent, fireSaxEndElement, fireSaxPIEvent, fireSaxSpaceEvents, fireSaxStartElement, getAttrCollector, getAttrCount, getAttrLocalName, getAttrNsURI, getAttrPrefix, getAttrPrefixedName, getAttrQName, getAttrType, getAttrValue, getAttrValue, getConfig, getCurrentLineNr, getDepth, getDTDPublicId, getDTDSystemId, getEndLocation, getInputPublicId, getInputSystemId, getName, getNamespacePrefix, getNamespaceURI, getNamespaceURI, getNamespaceURI, getNonTransientNamespaceContext, getNsCount, getPrefix, getPrefixes, getQName, getStartLocation, getText, getText, getTextCharacters, getTextCharacters, getTextLength, handleInvalidXmlChar, hasEmptyStack, isAttrSpecified, isEmptyTag, isTextWhitespace, loadMoreGuaranteed, loadMoreGuaranteed, reportDoubleHyphenInComments, reportDuplicateNsDecl, reportEntityOverflow, reportEofInName, reportIllegalCDataEnd, reportIllegalNsDecl, reportIllegalNsDecl, reportInputProblem, reportInvalidNameChar, reportInvalidNsIndex, reportInvalidXmlChar, reportMissingPISpace, reportMultipleColonsInName, reportPrologProblem, reportPrologUnexpChar, reportPrologUnexpElement, reportTreeUnexpChar, reportUnboundPrefix, reportUnexpandedEntityInAttr, reportUnexpectedEndTag, resetForDecoding, skipToken, throwInvalidSpace, throwNullChar, throwUnexpectedChar, verifyXmlChar`

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

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

    - ### Methods inherited from interface com.fasterxml.aalto.AsyncInputFeeder

      `endOfInput`

- - ### Field Detail

    - #### _inputBuffer

          protected ByteBuffer _inputBuffer

      This buffer is actually provided by caller

    - #### _origBufferLen

          protected int _origBufferLen

      In addition to current buffer pointer, and end pointer, we will also need to know number of bytes originally contained. This is needed to correctly update location information when the block has been completed.

  - ### Constructor Detail

    - #### AsyncByteBufferScanner

          public AsyncByteBufferScanner(ReaderConfig cfg)

  - ### Method Detail

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`

    - #### parseCommentContents

          protected int parseCommentContents()
                                      throws XMLStreamException

      Throws:
        `XMLStreamException`

    - #### handleCommentPending

          protected int handleCommentPending()
                                      throws XMLStreamException

      Returns:
        EVENT_INCOMPLETE, if there's not enough input to handle pending char, COMMENT, if we handled complete "-->" end marker, or 0 to indicate something else was succesfully handled.
      Throws:
        `XMLStreamException`

    - #### parsePIData

          protected int parsePIData()
                             throws XMLStreamException

      Throws:
        `XMLStreamException`

    - #### handlePIPending

          protected int handlePIPending()
                                 throws XMLStreamException

      Returns:
        EVENT_INCOMPLETE, if there's not enough input to handle pending char, PROCESSING_INSTRUCTION, if we handled complete "?>" end marker, or 0 to indicate something else was succesfully handled.
      Throws:
        `XMLStreamException`

    - #### handleDTDInternalSubset

          protected final boolean handleDTDInternalSubset(boolean init)
                                                   throws XMLStreamException

      Throws:
        `XMLStreamException`

    - #### parseCDataContents

          protected final int parseCDataContents()
                                          throws XMLStreamException

      Throws:
        `XMLStreamException`

    - #### handleCDataPending

          protected final int handleCDataPending()
                                          throws XMLStreamException

      Returns:
        EVENT_INCOMPLETE, if there's not enough input to handle pending char, CDATA, if we handled complete "]]>" end marker, or 0 to indicate something else was succesfully handled.
      Throws:
        `XMLStreamException`

    - #### startCharactersPending

          protected int startCharactersPending()
                                        throws XMLStreamException

      This method gets called, if the first character of a CHARACTERS event could not be fully read (multi-byte, split over buffer boundary). If so, there is some pending data to be handled.
      Throws:
        `XMLStreamException`

    - #### finishCharactersCoalescing

          protected final int finishCharactersCoalescing()
                                                  throws XMLStreamException

      TODO: Method not yet implemented
      Throws:
        `XMLStreamException`

    - #### needMoreInput

          public final boolean needMoreInput()

      Description copied from interface: `AsyncInputFeeder`
      Method called to check whether it is ok to feed more data: parser returns true if it has no more content to parse (and it is ok to feed more); otherwise false (and no data should yet be fed).
      Specified by:
        `needMoreInput` in interface `AsyncInputFeeder`

    - #### feedInput

          public void feedInput(ByteBuffer buffer)
                         throws XMLStreamException

      Description copied from interface: `AsyncByteBufferFeeder`
      Method that can be called to feed more data, if (and only if) `AsyncInputFeeder.needMoreInput()` returns true.
      Specified by:
        `feedInput` in interface `AsyncByteBufferFeeder`
      Parameters:
        `buffer` - Buffer that contains additional input to read
      Throws:
        `XMLStreamException` - if the state is such that this method should not be called (has not yet consumed existing input data, or has been marked as closed)

    - #### nextFromProlog

          public final int nextFromProlog(boolean isProlog)
                                   throws XMLStreamException

      Specified by:
        `nextFromProlog` in class `XmlScanner`
      Throws:
        `XMLStreamException`

    - #### nextFromTree

          public int nextFromTree()
                           throws XMLStreamException

      Specified by:
        `nextFromTree` in class `XmlScanner`
      Throws:
        `XMLStreamException`

    - #### handleEntityStartingToken

          protected int handleEntityStartingToken()
                                           throws XMLStreamException

      Method called when a new token (within tree) starts with an entity.
      Returns:
        Type of event to return
      Throws:
        `XMLStreamException`

    - #### handleNamedEntityStartingToken

          protected int handleNamedEntityStartingToken()
                                                throws XMLStreamException

      Method called when we see an entity that is starting a new token, and part of its name has been decoded (but not all)
      Throws:
        `XMLStreamException`

    - #### handleNumericEntityStartingToken

          protected int handleNumericEntityStartingToken()
                                                  throws XMLStreamException

      Method called to handle cases where we find something other than a character entity (or one of 4 pre-defined general entities that act like character entities)
      Throws:
        `XMLStreamException`

    - #### decodeHexEntity

          protected final boolean decodeHexEntity()
                                           throws XMLStreamException

      Returns:
        True if entity was decoded (and value assigned to `_entityValue`; false otherwise
      Throws:
        `XMLStreamException`

    - #### decodeDecEntity

          protected final boolean decodeDecEntity()
                                           throws XMLStreamException

      Returns:
        True if entity was decoded (and value assigned to `_entityValue`; false otherwise
      Throws:
        `XMLStreamException`

    - #### decodeGeneralEntity

          protected final int decodeGeneralEntity(PName entityName)
                                           throws XMLStreamException

      Method that verifies that given named entity is followed by a semi-colon (meaning next byte must be available for reading); and if so, whether it is one of pre-defined general entities.
      Returns:
        Character of the expanded pre-defined general entity (if name matches one); zero if not.
      Throws:
        `XMLStreamException`

    - #### handleStartElementStart

          protected int handleStartElementStart(byte b)
                                         throws XMLStreamException

      Method called when '<' and (what appears to be) a name start character have been seen.
      Throws:
        `XMLStreamException`

    - #### handleStartElement

          protected int handleStartElement()
                                    throws XMLStreamException

      Throws:
        `XMLStreamException`

    - #### startCharacters

          protected final int startCharacters(byte b)
                                       throws XMLStreamException

      Description copied from class: `AsyncByteScanner`
      Method called to initialize state for CHARACTERS event, after just a single byte has been seen. What needs to be done next depends on whether coalescing mode is set or not: if it is not set, just a single character needs to be decoded, after which current event will be incomplete, but defined as CHARACTERS. In coalescing mode, the whole content must be read before current event can be defined. The reason for difference is that when `XMLStreamReader.next()` returns, no blocking can occur when calling other methods.
      Specified by:
        `startCharacters` in class `AsyncByteScanner`
      Returns:
        Event type detected; either CHARACTERS, if at least one full character was decoded (and can be returned), EVENT_INCOMPLETE if not (part of a multi-byte character split across input buffer boundary)
      Throws:
        `XMLStreamException`

    - #### finishCharacters

          protected final void finishCharacters()
                                         throws XMLStreamException

      This method only gets called in non-coalescing mode; and if so, needs to parse as many characters of the current text segment from the current input block as possible.
      Specified by:
        `finishCharacters` in class `AsyncByteScanner`
      Throws:
        `XMLStreamException`

    - #### handleEntityInCharacters

          protected int handleEntityInCharacters()
                                          throws XMLStreamException

      Method called to handle entity encountered inside CHARACTERS segment, when trying to complete a non-coalescing text segment.

      NOTE: unlike with generic parsing of named entities, where trailing semicolon needs to be left in place, here we should just process it right away.

      Returns:
        Expanded (character) entity, if positive number; 0 if incomplete.
      Throws:
        `XMLStreamException`

    - #### handleDecEntityInCharacters

          protected int handleDecEntityInCharacters(int ptr)
                                             throws XMLStreamException

      Throws:
        `XMLStreamException`

    - #### handleHexEntityInCharacters

          protected int handleHexEntityInCharacters(int ptr)
                                             throws XMLStreamException

      Throws:
        `XMLStreamException`

    - #### skipCharacters

          protected boolean skipCharacters()
                                    throws XMLStreamException

      Method that will be called to skip all possible characters from the input buffer, but without blocking. Partial characters are not to be handled (not pending input is to be added).
      Specified by:
        `skipCharacters` in class `AsyncByteScanner`
      Returns:
        True, if skipping ending with an unexpanded entity; false if not
      Throws:
        `XMLStreamException`

    - #### skipCoalescedText

          protected boolean skipCoalescedText()
                                       throws XMLStreamException

      Coalescing mode is (and will) not be implemented for non-blocking parsers, so this method should never get called.
      Specified by:
        `skipCoalescedText` in class `XmlScanner`
      Returns:
        True, if an unexpanded entity was encountered (and is now pending)
      Throws:
        `XMLStreamException`

    - #### handleAttrValue

          protected boolean handleAttrValue()
                                     throws XMLStreamException

      Specified by:
        `handleAttrValue` in class `AsyncByteScanner`
      Returns:
        True, if the whole value was read; false if only part (due to buffer ending)
      Throws:
        `XMLStreamException`

    - #### handleEntityInAttributeValue

          protected int handleEntityInAttributeValue()
                                              throws XMLStreamException

      Method called to handle entity encountered inside attribute value.
      Returns:
        Value of expanded character entity, if processed (which must be 1 or above); 0 for general entity, or -1 for "not enough input"
      Throws:
        `XMLStreamException`

    - #### handleNsDecl

          protected boolean handleNsDecl()
                                  throws XMLStreamException

      Specified by:
        `handleNsDecl` in class `AsyncByteScanner`
      Throws:
        `XMLStreamException`

    - #### parseNewName

          protected PName parseNewName(byte b)
                                throws XMLStreamException

      Throws:
        `XMLStreamException`

    - #### parsePName

          protected PName parsePName()
                              throws XMLStreamException

      This method can (for now?) be shared between all Ascii-based encodings, since it only does coarse validity checking -- real checks are done in different method.

      Some notes about assumption implementation makes:

      - Well-formed xml content can not end with a name: as such, end-of-input is an error and we can throw an exception
      Throws:
        `XMLStreamException`

    - #### parseNewEntityName

          protected final PName parseNewEntityName(byte b)
                                            throws XMLStreamException

      Throws:
        `XMLStreamException`

    - #### parseEntityName

          protected final PName parseEntityName()
                                         throws XMLStreamException

      Throws:
        `XMLStreamException`

    - #### handlePartialCR

          protected final boolean handlePartialCR()

      Method called when there is a pending \r (from past buffer), and we need to see
      Returns:
        True if the linefeed was succesfully processed (had enough input data to do that); or false if there is no data available to check this

    - #### decodeUtf8_2

          protected final int decodeUtf8_2(int c)
                                    throws XMLStreamException

      Note: caller must guarantee enough data is available before calling the method

      Throws:
        `XMLStreamException`

    - #### skipUtf8_2

          protected final void skipUtf8_2(int c)
                                   throws XMLStreamException

      Throws:
        `XMLStreamException`

    - #### decodeUtf8_3

          protected final int decodeUtf8_3(int c1)
                                    throws XMLStreamException

      Note: caller must guarantee enough data is available before calling the method

      Throws:
        `XMLStreamException`

    - #### decodeUtf8_3

          protected final int decodeUtf8_3(int c1,
                         int c2,
                         int c3)
                                    throws XMLStreamException

      Throws:
        `XMLStreamException`

    - #### decodeUtf8_4

          protected final int decodeUtf8_4(int c)
                                    throws XMLStreamException

      Throws:
        `XMLStreamException`

    - #### decodeUtf8_4

          protected final int decodeUtf8_4(int c1,
                         int c2,
                         int c3,
                         int c4)
                                    throws XMLStreamException

      Returns:
        Character value minus 0x10000; this so that caller can readily expand it to actual surrogates
      Throws:
        `XMLStreamException`

Copyright © 2018 FasterXML. All rights reserved.