AsyncByteArrayScanner (aalto-xml 1.1.0 API)

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

All Implemented Interfaces:

AsyncByteArrayFeeder, AsyncInputFeeder, XmlConsts, NamespaceContext, XMLStreamConstants
```
public class AsyncByteArrayScanner
extends AsyncByteScanner
implements AsyncByteArrayFeeder
```
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 byte[]`	`_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

AsyncByteArrayScanner(ReaderConfig cfg)

Constructors
Constructor and Description
`AsyncByteArrayScanner(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(byte[] buf, int start, int len)` 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 byte[] _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
  - AsyncByteArrayScanner
```
public AsyncByteArrayScanner(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(byte[] buf,
             int start,
             int len)
               throws XMLStreamException
```
    Description copied from interface: AsyncByteArrayFeeder
    
    Method that can be called to feed more data, if (and only if) AsyncInputFeeder.needMoreInput() returns true.
    
    Specified by:
    
    feedInput in interface AsyncByteArrayFeeder
    
    Parameters:
    buf - Byte array that containts data to feed: caller must ensure data remains stable until it is fully processed (which is true when AsyncInputFeeder.needMoreInput() returns true)
    start - Offset within array where input data to process starts
    len - Length of input data within array to process.
    
    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

Class AsyncByteArrayScanner

Field Summary

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

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

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

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

Fields inherited from interface javax.xml.stream.XMLStreamConstants

Constructor Summary

Method Summary

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

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

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

Methods inherited from class java.lang.Object

Methods inherited from interface com.fasterxml.aalto.AsyncInputFeeder

Field Detail

_inputBuffer

_origBufferLen

Constructor Detail

AsyncByteArrayScanner

Method Detail

toString

parseCommentContents

handleCommentPending

parsePIData

handlePIPending

handleDTDInternalSubset

parseCDataContents

handleCDataPending

startCharactersPending

finishCharactersCoalescing

needMoreInput

feedInput

nextFromProlog

nextFromTree

handleEntityStartingToken

handleNamedEntityStartingToken

handleNumericEntityStartingToken

decodeHexEntity

decodeDecEntity

decodeGeneralEntity

handleStartElementStart

handleStartElement

startCharacters

finishCharacters

handleEntityInCharacters

handleDecEntityInCharacters

handleHexEntityInCharacters

skipCharacters

skipCoalescedText

handleAttrValue

handleEntityInAttributeValue

handleNsDecl

parseNewName

parsePName

parseNewEntityName

parseEntityName

handlePartialCR

decodeUtf8_2

skipUtf8_2

decodeUtf8_3

decodeUtf8_3

decodeUtf8_4

decodeUtf8_4