DOMWrappingReader (Stax2 API 3.1.4 API)

java.lang.Object
- org.codehaus.stax2.ri.dom.DOMWrappingReader

All Implemented Interfaces:

NamespaceContext, XMLStreamConstants, XMLStreamReader, AttributeInfo, DTDInfo, LocationInfo, TypedXMLStreamReader, Validatable, XMLStreamReader2
```
public abstract class DOMWrappingReader
extends Object
implements XMLStreamReader2, AttributeInfo, DTDInfo, LocationInfo, NamespaceContext, XMLStreamConstants
```
This is an adapter class that presents a DOM document as if it was a regular XMLStreamReader. This is mostly useful for inter-operability purposes, and should only be used when the input has to come as a DOM object and the original xml content is not available as a stream.
Note that the implementation is only to be used for use with javax.xml.transform.dom.DOMSource. It can however be used for both full documents, and single element root fragments, depending on what node is passed as the argument.
Some notes regarding missing/incomplete functionality:
- DOM does not seem to have access to information from the XML declaration (although Document node can be viewed as representing it). Consequently, all accessors return no information (version, encoding, standalone).
- No location info is provided, since (you guessed it!) DOM does not provide that info.

Field Summary

Fields
Modifier and Type	Field and Description
`protected List`	`_attrList` Lazily instantiated List of all actual attributes for the current (start) element, NOT including namespace declarations.
`protected StringBase64Decoder`	`_base64Decoder` Lazily-constructed decoder object for decoding base64 encoded binary content.
`protected boolean`	`_cfgInternNames` By default we do not force interning of names: can be reset by sub-classes.
`protected boolean`	`_cfgInternNsURIs` By default we do not force interning of namespace URIs: can be reset by sub-classes.
`protected boolean`	`_cfgNsAware` Whether stream reader is to be namespace aware (as per property `XMLInputFactory.IS_NAMESPACE_AWARE`) or not
`protected String`	`_coalescedText` In coalescing mode, we may need to combine textual content from multiple adjacent nodes.
`protected boolean`	`_coalescing` Whether stream reader is to coalesce adjacent textual (CHARACTERS, SPACE, CDATA) events (as per property `XMLInputFactory.IS_COALESCING`) or not
`protected int`	`_currEvent`
`protected Node`	`_currNode` Current node is the DOM node that contains information regarding the current event.
`protected ValueDecoderFactory`	`_decoderFactory` Factory used for constructing decoders we need for typed access
`protected int`	`_depth`
`protected List`	`_nsDeclList` Lazily instantiated String pairs of all namespace declarations for the current (start/end) element.
`protected Node`	`_rootNode`
`protected String`	`_systemId`
`protected Stax2Util.TextBuffer`	`_textBuffer` Helper object used for combining segments of text as needed
`protected static int`	`ERR_STATE_NO_LOCALNAME`
`protected static int`	`ERR_STATE_NOT_ELEM` Current state not START_ELEMENT or END_ELEMENT, should be
`protected static int`	`ERR_STATE_NOT_PI` Current state not PROCESSING_INSTRUCTION
`protected static int`	`ERR_STATE_NOT_START_ELEM` Current state not START_ELEMENT, should be
`protected static int`	`ERR_STATE_NOT_TEXTUAL` Current state not one where getText() can be used
`protected static int`	`ERR_STATE_NOT_TEXTUAL_OR_ELEM`
`protected static int`	`ERR_STATE_NOT_TEXTUAL_XXX` Current state not one where getTextXxx() can be used
`protected static int`	`INT_SPACE`
`protected static int`	`MASK_TYPED_ACCESS_BINARY`

Fields inherited from interface org.codehaus.stax2.XMLStreamReader2
FEATURE_DTD_OVERRIDE

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
Modifier Constructor and Description

protected DOMWrappingReader(DOMSource src, boolean nsAware, boolean coalescing)

Constructors
Modifier	Constructor and Description
`protected`	`DOMWrappingReader(DOMSource src, boolean nsAware, boolean coalescing)`

Method Summary

Methods
Modifier and Type	Method and Description
`protected StringBase64Decoder`	`_base64Decoder()`
`protected TypedXMLStreamException`	`_constructTypeException(IllegalArgumentException iae, String lexicalValue)` Method called to wrap or convert given conversion-fail exception into a full `TypedXMLStreamException`,
`protected TypedXMLStreamException`	`_constructTypeException(String msg, String lexicalValue)`
`protected ValueDecoderFactory`	`_decoderFactory()`
`protected int`	`_getAttributeAsArray(TypedArrayDecoder tad, String attrValue)`
`protected String`	`_internName(String name)` Method called to do additional intern()ing for a name, if and as necessary
`protected String`	`_internNsURI(String uri)`
`void`	`close()` Note: as per StAX 1.0 specs, this method does NOT close the underlying input reader.
`void`	`closeCompletely()` Method similar to `XMLStreamReader.close()`, except that this method also does close the underlying input source if it has not yet been closed.
`protected void`	`coalesceText(int initialType)`
`int`	`findAttributeIndex(String nsURI, String localName)`
`protected String`	`findErrorDesc(int errorType, int currEvent)` Method used to locate error message description to use.
`void`	`getAttributeAs(int index, TypedValueDecoder tvd)` Generic access method that can be used for efficient decoding of additional types not support natively by the typed stream reader.
`int`	`getAttributeAsArray(int index, TypedArrayDecoder tad)` Method that allows reading contents of an attribute as an array of whitespace-separate tokens, decoded using specified decoder.
`byte[]`	`getAttributeAsBinary(int index)` Read an attribute value as a byte array.
`byte[]`	`getAttributeAsBinary(int index, Base64Variant v)`
`boolean`	`getAttributeAsBoolean(int index)` Read an attribute value as a boolean.
`BigDecimal`	`getAttributeAsDecimal(int index)`
`double`	`getAttributeAsDouble(int index)`
`double[]`	`getAttributeAsDoubleArray(int index)`
`float`	`getAttributeAsFloat(int index)`
`float[]`	`getAttributeAsFloatArray(int index)`
`int`	`getAttributeAsInt(int index)` Read an attribute value as a boolean.
`int[]`	`getAttributeAsIntArray(int index)` Read an attribute content as an int array.
`BigInteger`	`getAttributeAsInteger(int index)`
`long`	`getAttributeAsLong(int index)` Read an attribute value as a boolean.
`long[]`	`getAttributeAsLongArray(int index)`
`QName`	`getAttributeAsQName(int index)`
`int`	`getAttributeCount()`
`int`	`getAttributeIndex(String namespaceURI, String localName)` Returns the index of the attribute whose local name is `localName` and URI is `namespaceURI` or `-1` if no such attribute exists.
`AttributeInfo`	`getAttributeInfo()` Method that can be called to get additional information about attributes related to the current start element, as well as related DTD-based information if available.
`String`	`getAttributeLocalName(int index)`
`QName`	`getAttributeName(int index)`
`String`	`getAttributeNamespace(int index)`
`String`	`getAttributePrefix(int index)`
`String`	`getAttributeType(int index)`
`String`	`getAttributeValue(int index)`
`String`	`getAttributeValue(String nsURI, String localName)`
`String`	`getCharacterEncodingScheme()` As per Stax (1.0) specs, needs to return whatever xml declaration claimed encoding is, if any; or null if no xml declaration found.
`XMLStreamLocation2`	`getCurrentLocation()` A method that returns the current location of the stream reader at the input source.
`int`	`getDepth()` Method that returns the number of open elements in the stack; 0 when the reader is in prolog/epilog, 1 inside root element (including when pointing at the root element itself) and so on.
`DTDInfo`	`getDTDInfo()` Since this class implements `DTDInfo`, method can just return `this`.
`String`	`getDTDInternalSubset()`
`String`	`getDTDPublicId()`
`String`	`getDTDRootName()`
`String`	`getDTDSystemId()`
`void`	`getElementAs(TypedValueDecoder tvd)` Generic decoding method that can be used for efficient decoding of additional types not support natively by the typed stream reader.
`byte[]`	`getElementAsBinary()` Convenience method that can be used similar to read binary content instead of `TypedXMLStreamReader.readElementAsBinary(byte[], int, int, org.codehaus.stax2.typed.Base64Variant)`, in cases where neither performance nor memory usage is a big concern.
`byte[]`	`getElementAsBinary(Base64Variant v)` Convenience method that can be used similar to read binary content instead of `TypedXMLStreamReader.readElementAsBinary(byte[], int, int, org.codehaus.stax2.typed.Base64Variant)`, in cases where neither performance nor memory usage is a big concern.
`boolean`	`getElementAsBoolean()` Read an element content as a boolean.
`BigDecimal`	`getElementAsDecimal()`
`double`	`getElementAsDouble()` Read an element content as a 64-bit floating point value.
`float`	`getElementAsFloat()` Read an element content as a 32-bit floating point value.
`int`	`getElementAsInt()` Read an element content as a 32-bit integer.
`BigInteger`	`getElementAsInteger()`
`long`	`getElementAsLong()` Read an element content as a 64-bit integer.
`QName`	`getElementAsQName()`
`String`	`getElementText()` From StAX specs: Reads the content of a text-only element, an exception is thrown if this is not a text-only element.
`String`	`getEncoding()` As per Stax (1.0) specs, needs to return whatever parser determined the encoding was, if it was able to figure it out.
`long`	`getEndingByteOffset()` Method that can be used to get exact byte offset (number of bytes read from the stream right before getting to this location) in the stream that is pointed to by this reader, right after the end of the current event.
`long`	`getEndingCharOffset()` Method that can be used to get exact character offset (number of chars read from the stream right before getting to this location) in the stream that is pointed to by this reader, right after the end of the current event.
`XMLStreamLocation2`	`getEndLocation()` An optional method that either returns the location object that points the ending position of the current event, or null if implementation does not keep track of it (some may return only start location; and some no location at all).
`protected Location`	`getErrorLocation()`
`int`	`getEventType()` Returns type of the last event returned; or START_DOCUMENT before any events has been explicitly returned.
`Object`	`getFeature(String name)` Method that can be used to get per-reader values; both generic ones (names for which are defined as constants in this class), and implementation dependant ones.
`int`	`getIdAttributeIndex()` Returns the index of the id attribute (attribute with any name, type ID from DTD) of current (start) element, if any.
`String`	`getLocalName()`
`Location`	`getLocation()`
`LocationInfo`	`getLocationInfo()` Location information is always accessible, for this reader.
`QName`	`getName()`
`NamespaceContext`	`getNamespaceContext()`
`int`	`getNamespaceCount()`
`String`	`getNamespacePrefix(int index)` Alas, DOM does not expose any of information necessary for determining actual declarations.
`String`	`getNamespaceURI()`
`String`	`getNamespaceURI(int index)`
`String`	`getNamespaceURI(String prefix)`
`NamespaceContext`	`getNonTransientNamespaceContext()` This method returns a namespace context object that contains information identical to that returned by `XMLStreamReader.getNamespaceContext()`, but one that is not transient.
`int`	`getNotationAttributeIndex()` Returns the index of the notation attribute (attribute with any name, type NOTATION from DTD) of current (start) element, if any.
`String`	`getPIData()`
`String`	`getPITarget()`
`String`	`getPrefix()`
`String`	`getPrefix(String namespaceURI)`
`String`	`getPrefixedName()` This method returns "prefix-qualified" name of the current element.
`Iterator`	`getPrefixes(String namespaceURI)`
`Object`	`getProcessedDTD()`
`DTDValidationSchema`	`getProcessedDTDSchema()` Method similar to `DTDInfo.getProcessedDTD()`, but type-safe.
`abstract Object`	`getProperty(String name)`
`long`	`getStartingByteOffset()` Method that can be used to get exact byte offset (number of bytes read from the stream right before getting to this location) in the stream that is pointed to by this reader, right before the start of the current event.
`long`	`getStartingCharOffset()` Method that can be used to get exact character offset (number of chars read from the stream right before getting to this location) in the stream that is pointed to by this reader, right before the start of the current event.
`XMLStreamLocation2`	`getStartLocation()` An optional method that either returns the location object that points the starting position of the current event, or null if implementation does not keep track of it (some may return only end location; and some no location at all).
`String`	`getText()`
`int`	`getText(Writer w, boolean preserveContents)` Method similar to `getText()`, except that it just uses provided Writer to write all textual content.
`char[]`	`getTextCharacters()`
`int`	`getTextCharacters(int sourceStart, char[] target, int targetStart, int len)`
`int`	`getTextLength()`
`int`	`getTextStart()`
`String`	`getVersion()`
`boolean`	`hasName()`
`boolean`	`hasNext()`
`boolean`	`hasText()`
`boolean`	`isAttributeSpecified(int index)`
`boolean`	`isCharacters()`
`boolean`	`isEmptyElement()` Method that can be used to check whether current START_ELEMENT event was created for an empty element (xml short-hand notation where one tag implies start and end, ending with "/>"), or not.
`boolean`	`isEndElement()`
`abstract boolean`	`isPropertySupported(String name)` Method similar to `XMLInputFactory.isPropertySupported(java.lang.String)`, used to determine whether a property is supported by the Reader instance.
`boolean`	`isStandalone()`
`boolean`	`isStartElement()`
`boolean`	`isWhiteSpace()`
`int`	`next()`
`int`	`nextTag()`
`int`	`readElementAsArray(TypedArrayDecoder tad)` Read an element content as an array of tokens.
`int`	`readElementAsBinary(byte[] resultBuffer, int offset, int maxLength)`
`int`	`readElementAsBinary(byte[] resultBuffer, int offset, int maxLength, Base64Variant v)` Read element content as decoded byte sequence; possibly only reading a fragment of all element content.
`int`	`readElementAsDoubleArray(double[] value, int from, int length)`
`int`	`readElementAsFloatArray(float[] value, int from, int length)`
`int`	`readElementAsIntArray(int[] value, int from, int length)` Read an element content as an int array.
`int`	`readElementAsLongArray(long[] value, int from, int length)`
`protected void`	`reportParseProblem(int errorType)`
`protected void`	`reportWrongState(int errorType)`
`void`	`require(int type, String nsUri, String localName)`
`void`	`setFeature(String name, Object value)` Method that can be used to set per-reader features such as configuration settings; both generic ones (names for which are defined as constants in this class), and implementation dependant ones.
`protected void`	`setInternNames(boolean state)`
`protected void`	`setInternNsURIs(boolean state)`
`abstract boolean`	`setProperty(String name, Object value)` Method that can be used to set per-reader properties; a subset of properties one can set via matching `XMLInputFactory2` instance.
`ValidationProblemHandler`	`setValidationProblemHandler(ValidationProblemHandler h)` Method that application can call to define a custom handler for validation problems encountered during validation process.
`void`	`skipElement()` Method that will skip all the contents of the element that the stream currently points to.
`boolean`	`standaloneSet()`
`XMLValidator`	`stopValidatingAgainst(XMLValidationSchema schema)` Method that can be called by application to stop validating output against a schema, for which `Validatable.validateAgainst(org.codehaus.stax2.validation.XMLValidationSchema)` was called earlier.
`XMLValidator`	`stopValidatingAgainst(XMLValidator validator)` Method that can be called by application to stop validating output using specified validator.
`protected void`	`throwStreamException(String msg)`
`protected abstract void`	`throwStreamException(String msg, Location loc)`
`XMLValidator`	`validateAgainst(XMLValidationSchema schema)` Method that will construct a `XMLValidator` instance from the given schema (unless a validator for that schema has already been added), initialize it if necessary, and make validatable object (reader, writer) call appropriate validation methods from this point on until the end of the document (that is, it's not scoped with sub-trees), or until validator is removed by an explicit call to `Validatable.stopValidatingAgainst(org.codehaus.stax2.validation.XMLValidationSchema)`.

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

- Field Detail
  - INT_SPACE
```
protected static final int INT_SPACE
```
    See Also:
    Constant Field Values
  - MASK_TYPED_ACCESS_BINARY
```
protected static final int MASK_TYPED_ACCESS_BINARY
```
    See Also:
    Constant Field Values
  - ERR_STATE_NOT_START_ELEM
```
protected static final int ERR_STATE_NOT_START_ELEM
```
    Current state not START_ELEMENT, should be
    
    See Also:
    Constant Field Values
  - ERR_STATE_NOT_ELEM
```
protected static final int ERR_STATE_NOT_ELEM
```
    Current state not START_ELEMENT or END_ELEMENT, should be
    
    See Also:
    Constant Field Values
  - ERR_STATE_NOT_PI
```
protected static final int ERR_STATE_NOT_PI
```
    Current state not PROCESSING_INSTRUCTION
    
    See Also:
    Constant Field Values
  - ERR_STATE_NOT_TEXTUAL
```
protected static final int ERR_STATE_NOT_TEXTUAL
```
    Current state not one where getText() can be used
    
    See Also:
    Constant Field Values
  - ERR_STATE_NOT_TEXTUAL_XXX
```
protected static final int ERR_STATE_NOT_TEXTUAL_XXX
```
    Current state not one where getTextXxx() can be used
    
    See Also:
    Constant Field Values
  - ERR_STATE_NOT_TEXTUAL_OR_ELEM
```
protected static final int ERR_STATE_NOT_TEXTUAL_OR_ELEM
```
    See Also:
    Constant Field Values
  - ERR_STATE_NO_LOCALNAME
```
protected static final int ERR_STATE_NO_LOCALNAME
```
    See Also:
    Constant Field Values
  - _systemId
```
protected final String _systemId
```
  - _rootNode
```
protected final Node _rootNode
```
  - _cfgNsAware
```
protected final boolean _cfgNsAware
```
    Whether stream reader is to be namespace aware (as per property XMLInputFactory.IS_NAMESPACE_AWARE) or not
  - _coalescing
```
protected final boolean _coalescing
```
    Whether stream reader is to coalesce adjacent textual (CHARACTERS, SPACE, CDATA) events (as per property XMLInputFactory.IS_COALESCING) or not
  - _cfgInternNames
```
protected boolean _cfgInternNames
```
    By default we do not force interning of names: can be reset by sub-classes.
  - _cfgInternNsURIs
```
protected boolean _cfgInternNsURIs
```
    By default we do not force interning of namespace URIs: can be reset by sub-classes.
  - _currEvent
```
protected int _currEvent
```
  - _currNode
```
protected Node _currNode
```
    Current node is the DOM node that contains information regarding the current event.
  - _depth
```
protected int _depth
```
  - _coalescedText
```
protected String _coalescedText
```
    In coalescing mode, we may need to combine textual content from multiple adjacent nodes. Since we shouldn't be modifying the underlying DOM tree, need to accumulate it into a temporary variable
  - _textBuffer
```
protected Stax2Util.TextBuffer _textBuffer
```
    Helper object used for combining segments of text as needed
  - _attrList
```
protected List _attrList
```
    Lazily instantiated List of all actual attributes for the current (start) element, NOT including namespace declarations. As such, elements are Attr instances.
  - _nsDeclList
```
protected List _nsDeclList
```
    Lazily instantiated String pairs of all namespace declarations for the current (start/end) element. String pair means that for each declarations there are two Strings in the list: first one is prefix (empty String for the default namespace declaration), and second URI it is bound to.
  - _decoderFactory
```
protected ValueDecoderFactory _decoderFactory
```
    Factory used for constructing decoders we need for typed access
  - _base64Decoder
```
protected StringBase64Decoder _base64Decoder
```
    Lazily-constructed decoder object for decoding base64 encoded binary content.
- Constructor Detail
  - DOMWrappingReader
```
protected DOMWrappingReader(DOMSource src,
                 boolean nsAware,
                 boolean coalescing)
                     throws XMLStreamException
```
    Parameters:
    src - Node that is the tree of the DOM document, or fragment.
    nsAware - Whether resulting reader should operate in namespace aware mode or not. Note that this should be compatible with settings for the DOM builder that produced DOM tree or fragment being operated on, otherwise results are not defined.
    coalescing - Whether resulting reader should coalesce adjacent text events or not
    
    Throws:
    
    XMLStreamException
- Method Detail
  - setInternNames
```
protected void setInternNames(boolean state)
```
  - setInternNsURIs
```
protected void setInternNsURIs(boolean state)
```
  - throwStreamException
```
protected abstract void throwStreamException(String msg,
                        Location loc)
                                      throws XMLStreamException
```
    Throws:
    
    XMLStreamException
  - getCharacterEncodingScheme
```
public String getCharacterEncodingScheme()
```
    As per Stax (1.0) specs, needs to return whatever xml declaration claimed encoding is, if any; or null if no xml declaration found.
    
    Specified by:
    
    getCharacterEncodingScheme in interface XMLStreamReader
  - getEncoding
```
public String getEncoding()
```
    As per Stax (1.0) specs, needs to return whatever parser determined the encoding was, if it was able to figure it out. If not (there are cases where this can not be found; specifically when being passed a Reader), it should return null.
    
    Specified by:
    
    getEncoding in interface XMLStreamReader
  - getVersion
```
public String getVersion()
```
    Specified by:
    
    getVersion in interface XMLStreamReader
  - isStandalone
```
public boolean isStandalone()
```
    Specified by:
    
    isStandalone in interface XMLStreamReader
  - standaloneSet
```
public boolean standaloneSet()
```
    Specified by:
    
    standaloneSet in interface XMLStreamReader
  - getProperty
```
public abstract Object getProperty(String name)
```
    Specified by:
    
    getProperty in interface XMLStreamReader
  - isPropertySupported
```
public abstract boolean isPropertySupported(String name)
```
    Description copied from interface: XMLStreamReader2
    
    Method similar to XMLInputFactory.isPropertySupported(java.lang.String), used to determine whether a property is supported by the Reader instance. This means that this method may return false for some properties that the input factory does support: specifically, it should only return true if the value is mutable on per-instance basis. False means that either the property is not recognized, or is not mutable via reader instance.
    
    Specified by:
    
    isPropertySupported in interface XMLStreamReader2
  - setProperty
```
public abstract boolean setProperty(String name,
                  Object value)
```
    Description copied from interface: XMLStreamReader2
    
    Method that can be used to set per-reader properties; a subset of properties one can set via matching XMLInputFactory2 instance. Exactly which methods are mutable is implementation specific.
    
    Specified by:
    
    setProperty in interface XMLStreamReader2
    
    Parameters:
    name - Name of the property to set
    value - Value to set property to.
    
    Returns:
    True, if the specified property was succesfully set to specified value; false if its value was not changed
  - getAttributeCount
```
public int getAttributeCount()
```
    Specified by:
    
    getAttributeCount in interface XMLStreamReader
    
    Specified by:
    
    getAttributeCount in interface AttributeInfo
    
    Returns:
    Number of all attributes accessible (including ones created from the default values, if any) using this Object.
  - getAttributeLocalName
```
public String getAttributeLocalName(int index)
```
    Specified by:
    
    getAttributeLocalName in interface XMLStreamReader
  - getAttributeName
```
public QName getAttributeName(int index)
```
    Specified by:
    
    getAttributeName in interface XMLStreamReader
  - getAttributeNamespace
```
public String getAttributeNamespace(int index)
```
    Specified by:
    
    getAttributeNamespace in interface XMLStreamReader
  - getAttributePrefix
```
public String getAttributePrefix(int index)
```
    Specified by:
    
    getAttributePrefix in interface XMLStreamReader
  - getAttributeType
```
public String getAttributeType(int index)
```
    Specified by:
    
    getAttributeType in interface XMLStreamReader
  - getAttributeValue
```
public String getAttributeValue(int index)
```
    Specified by:
    
    getAttributeValue in interface XMLStreamReader
  - getAttributeValue
```
public String getAttributeValue(String nsURI,
                       String localName)
```
    Specified by:
    
    getAttributeValue in interface XMLStreamReader
  - getElementText
```
public String getElementText()
                      throws XMLStreamException
```
    From StAX specs:
    Reads the content of a text-only element, an exception is thrown if this is not a text-only element. Regardless of value of javax.xml.stream.isCoalescing this method always returns coalesced content.
    Precondition: the current event is START_ELEMENT.
    Postcondition: the current event is the corresponding END_ELEMENT.
    
    Specified by:
    
    getElementText in interface XMLStreamReader
    
    Throws:
    
    XMLStreamException
  - getEventType
```
public int getEventType()
```
    Returns type of the last event returned; or START_DOCUMENT before any events has been explicitly returned.
    
    Specified by:
    
    getEventType in interface XMLStreamReader
  - getLocalName
```
public String getLocalName()
```
    Specified by:
    
    getLocalName in interface XMLStreamReader
  - getLocation
```
public final Location getLocation()
```
    Specified by:
    
    getLocation in interface XMLStreamReader
    
    Specified by:
    
    getLocation in interface LocationInfo
  - getName
```
public QName getName()
```
    Specified by:
    
    getName in interface XMLStreamReader
  - getNamespaceContext
```
public NamespaceContext getNamespaceContext()
```
    Specified by:
    
    getNamespaceContext in interface XMLStreamReader
  - getNamespaceCount
```
public int getNamespaceCount()
```
    Specified by:
    
    getNamespaceCount in interface XMLStreamReader
  - getNamespacePrefix
```
public String getNamespacePrefix(int index)
```
    Alas, DOM does not expose any of information necessary for determining actual declarations. Thus, have to indicate that there are no declarations.
    
    Specified by:
    
    getNamespacePrefix in interface XMLStreamReader
  - getNamespaceURI
```
public String getNamespaceURI()
```
    Specified by:
    
    getNamespaceURI in interface XMLStreamReader
  - getNamespaceURI
```
public String getNamespaceURI(int index)
```
    Specified by:
    
    getNamespaceURI in interface XMLStreamReader
  - getPIData
```
public String getPIData()
```
    Specified by:
    
    getPIData in interface XMLStreamReader
  - getPITarget
```
public String getPITarget()
```
    Specified by:
    
    getPITarget in interface XMLStreamReader
  - getPrefix
```
public String getPrefix()
```
    Specified by:
    
    getPrefix in interface XMLStreamReader
  - getText
```
public String getText()
```
    Specified by:
    
    getText in interface XMLStreamReader
  - getTextCharacters
```
public char[] getTextCharacters()
```
    Specified by:
    
    getTextCharacters in interface XMLStreamReader
  - getTextCharacters
```
public int getTextCharacters(int sourceStart,
                    char[] target,
                    int targetStart,
                    int len)
```
    Specified by:
    
    getTextCharacters in interface XMLStreamReader
  - getTextLength
```
public int getTextLength()
```
    Specified by:
    
    getTextLength in interface XMLStreamReader
  - getTextStart
```
public int getTextStart()
```
    Specified by:
    
    getTextStart in interface XMLStreamReader
  - hasName
```
public boolean hasName()
```
    Specified by:
    
    hasName in interface XMLStreamReader
  - hasNext
```
public boolean hasNext()
```
    Specified by:
    
    hasNext in interface XMLStreamReader
  - hasText
```
public boolean hasText()
```
    Specified by:
    
    hasText in interface XMLStreamReader
  - isAttributeSpecified
```
public boolean isAttributeSpecified(int index)
```
    Specified by:
    
    isAttributeSpecified in interface XMLStreamReader
  - isCharacters
```
public boolean isCharacters()
```
    Specified by:
    
    isCharacters in interface XMLStreamReader
  - isEndElement
```
public boolean isEndElement()
```
    Specified by:
    
    isEndElement in interface XMLStreamReader
  - isStartElement
```
public boolean isStartElement()
```
    Specified by:
    
    isStartElement in interface XMLStreamReader
  - isWhiteSpace
```
public boolean isWhiteSpace()
```
    Specified by:
    
    isWhiteSpace in interface XMLStreamReader
  - require
```
public void require(int type,
           String nsUri,
           String localName)
             throws XMLStreamException
```
    Specified by:
    
    require in interface XMLStreamReader
    
    Throws:
    
    XMLStreamException
  - next
```
public int next()
         throws XMLStreamException
```
    Specified by:
    
    next in interface XMLStreamReader
    
    Throws:
    
    XMLStreamException
  - nextTag
```
public int nextTag()
            throws XMLStreamException
```
    Specified by:
    
    nextTag in interface XMLStreamReader
    
    Throws:
    
    XMLStreamException
  - close
```
public void close()
           throws XMLStreamException
```
    Note: as per StAX 1.0 specs, this method does NOT close the underlying input reader. That is, unless the new StAX2 property XMLInputFactory2.P_AUTO_CLOSE_INPUT is set to true.
    
    Specified by:
    
    close in interface XMLStreamReader
    
    Throws:
    
    XMLStreamException
  - getNamespaceURI
```
public String getNamespaceURI(String prefix)
```
    Specified by:
    
    getNamespaceURI in interface NamespaceContext
    
    Specified by:
    
    getNamespaceURI in interface XMLStreamReader
  - getPrefix
```
public String getPrefix(String namespaceURI)
```
    Specified by:
    
    getPrefix in interface NamespaceContext
  - getPrefixes
```
public Iterator getPrefixes(String namespaceURI)
```
    Specified by:
    
    getPrefixes in interface NamespaceContext
  - getElementAsBoolean
```
public boolean getElementAsBoolean()
                            throws XMLStreamException
```
    Description copied from interface: TypedXMLStreamReader
    Read an element content as a boolean. The lexical representation of a boolean is defined by the XML Schema boolean data type. Whitespace MUST be collapsed according to the whiteSpace facet for the XML Schema boolean data type. An exception is thrown if, after whitespace is collapsed, the resulting sequence of characters is not in the lexical space defined by the XML Schema boolean data type. (note: allowed lexical values are canonicals "true" and "false", as well as non-canonical "0" and "1")
    
    These are the pre- and post-conditions of calling this method:
    - Precondition: the current event is START_ELEMENT.
    - Postcondition: the current event is the corresponding END_ELEMENT.
    Specified by:
    
    getElementAsBoolean in interface TypedXMLStreamReader
    
    Throws:
    
    XMLStreamException - If unable to access content
    
    TypedXMLStreamException - If unable to convert the resulting character sequence into an XML Schema boolean value.
  - getElementAsInt
```
public int getElementAsInt()
                    throws XMLStreamException
```
    Description copied from interface: TypedXMLStreamReader
    Read an element content as a 32-bit integer. The lexical representation of a integer is defined by the XML Schema integer data type. Whitespace MUST be collapsed according to the whiteSpace facet for the XML Schema integer data type. An exception is thrown if, after whitespace is collapsed, the resulting sequence of characters is not in the lexical space defined by the XML Schema integer data type.
    These are the pre and post conditions of calling this method:
    - Precondition: the current event is START_ELEMENT.
    - Postcondition: the current event is the corresponding END_ELEMENT.
    Specified by:
    
    getElementAsInt in interface TypedXMLStreamReader
    
    Throws:
    
    XMLStreamException - If unable to access content
    
    TypedXMLStreamException - If unable to convert the resulting character sequence into a Java (32-bit) integer.
  - getElementAsLong
```
public long getElementAsLong()
                      throws XMLStreamException
```
    Description copied from interface: TypedXMLStreamReader
    Read an element content as a 64-bit integer. The lexical representation of a integer is defined by the XML Schema integer data type. Whitespace MUST be collapsed according to the whiteSpace facet for the XML Schema integer data type. An exception is thrown if, after whitespace is collapsed, the resulting sequence of characters is not in the lexical space defined by the XML Schema integer data type.
    These are the pre and post conditions of calling this method:
    - Precondition: the current event is START_ELEMENT.
    - Postcondition: the current event is the corresponding END_ELEMENT.
    Specified by:
    
    getElementAsLong in interface TypedXMLStreamReader
    
    Throws:
    
    XMLStreamException - If unable to access content
    
    TypedXMLStreamException - If unable to convert the resulting character sequence into a Java (64-bit) integer.
  - getElementAsFloat
```
public float getElementAsFloat()
                        throws XMLStreamException
```
    Description copied from interface: TypedXMLStreamReader
    Read an element content as a 32-bit floating point value. The lexical representation is defined by the XML Schema float data type. Whitespace MUST be collapsed according to the whiteSpace facet for the XML Schema float data type. An exception is thrown if, after whitespace is collapsed, the resulting sequence of characters is not in the lexical space defined by the XML Schema integer data type.
    Note that valid representations include basic Java textual representations, as well as 3 special tokens: "INF", "-INF" and "NaN"
    
    These are the pre and post conditions of calling this method:
    - Precondition: the current event is START_ELEMENT.
    - Postcondition: the current event is the corresponding END_ELEMENT.
    Specified by:
    
    getElementAsFloat in interface TypedXMLStreamReader
    
    Throws:
    
    XMLStreamException - If unable to access content
    
    TypedXMLStreamException - If unable to convert the resulting character sequence into a Java float
  - getElementAsDouble
```
public double getElementAsDouble()
                          throws XMLStreamException
```
    Description copied from interface: TypedXMLStreamReader
    Read an element content as a 64-bit floating point value. The lexical representation is defined by the XML Schema double data type. Whitespace MUST be collapsed according to the whiteSpace facet for the XML Schema double data type. An exception is thrown if, after whitespace is collapsed, the resulting sequence of characters is not in the lexical space defined by the XML Schema integer data type.
    Note that valid representations include basic Java textual representations, as well as 3 special tokens: "INF", "-INF" and "NaN"
    These are the pre and post conditions of calling this method:
    - Precondition: the current event is START_ELEMENT.
    - Postcondition: the current event is the corresponding END_ELEMENT.
    Specified by:
    
    getElementAsDouble in interface TypedXMLStreamReader
    
    Throws:
    
    XMLStreamException - If unable to access content
    
    TypedXMLStreamException - If unable to convert the resulting character sequence into a Java double
  - getElementAsInteger
```
public BigInteger getElementAsInteger()
                               throws XMLStreamException
```
    Specified by:
    
    getElementAsInteger in interface TypedXMLStreamReader
    
    Throws:
    
    XMLStreamException
  - getElementAsDecimal
```
public BigDecimal getElementAsDecimal()
                               throws XMLStreamException
```
    Specified by:
    
    getElementAsDecimal in interface TypedXMLStreamReader
    
    Throws:
    
    XMLStreamException
  - getElementAsQName
```
public QName getElementAsQName()
                        throws XMLStreamException
```
    Specified by:
    
    getElementAsQName in interface TypedXMLStreamReader
    
    Throws:
    
    XMLStreamException
  - getElementAsBinary
```
public byte[] getElementAsBinary()
                          throws XMLStreamException
```
    Description copied from interface: TypedXMLStreamReader
    
    Convenience method that can be used similar to read binary content instead of TypedXMLStreamReader.readElementAsBinary(byte[], int, int, org.codehaus.stax2.typed.Base64Variant), in cases where neither performance nor memory usage is a big concern.
    Note: base64 variant defaults to Base64Variants.MIME.
    
    Specified by:
    
    getElementAsBinary in interface TypedXMLStreamReader
    
    Throws:
    
    XMLStreamException
    See Also:
    TypedXMLStreamReader.readElementAsBinary(byte[], int, int, org.codehaus.stax2.typed.Base64Variant)
  - getElementAsBinary
```
public byte[] getElementAsBinary(Base64Variant v)
                          throws XMLStreamException
```
    Description copied from interface: TypedXMLStreamReader
    
    Convenience method that can be used similar to read binary content instead of TypedXMLStreamReader.readElementAsBinary(byte[], int, int, org.codehaus.stax2.typed.Base64Variant), in cases where neither performance nor memory usage is a big concern.
    
    Specified by:
    
    getElementAsBinary in interface TypedXMLStreamReader
    
    Parameters:
    v - Base64 variant content is in; needed to decode alternative variants ("modified base64")
    
    Throws:
    
    XMLStreamException
    See Also:
    TypedXMLStreamReader.readElementAsBinary(byte[], int, int, org.codehaus.stax2.typed.Base64Variant)
  - getElementAs
```
public void getElementAs(TypedValueDecoder tvd)
                  throws XMLStreamException
```
    Description copied from interface: TypedXMLStreamReader
    Generic decoding method that can be used for efficient decoding of additional types not support natively by the typed stream reader. When method is called, stream reader will collect all textual content of the current element (effectively doing something similar to a call to XMLStreamReader.getElementText(), and then call one of decode methods defined in TypedValueDecoder. The only difference is that passed value will be trimmed: that is, any leading or trailing white space will be removed prior to calling decode method. After the call, passed decoder object will have decoded and stored value (if succesful) or thrown an exception (if not).
    The main benefit of using this method (over just getting all content by calling XMLStreamReader.getElementText() is efficiency: the stream reader can efficiently gather all textual content necessary and pass it to the decoder, often avoiding construction of intemediate Strings.
    These are the pre- and post-conditions of calling this method:
    - Precondition: the current event is START_ELEMENT.
    - Postcondition: the current event is the corresponding END_ELEMENT.
    Note that caller has to know more specific type of decoder, since the base interface does not specify methods for accessing actual decoded value.
    Specified by:
    
    getElementAs in interface TypedXMLStreamReader
    
    Throws:
    
    XMLStreamException
  - readElementAsIntArray
```
public int readElementAsIntArray(int[] value,
                        int from,
                        int length)
                          throws XMLStreamException
```
    Description copied from interface: TypedXMLStreamReader
    Read an element content as an int array. The lexical representation of a int array is defined by the following XML schema type:
```
    <xs:simpleType name="intArray">
       <xs:list itemType="xs:int"/>
    </xs:simpleType>
```
    whose lexical space is a list of space-separated ints. Whitespace MUST be collapsed according to the whiteSpace facet for the intArray type shown above. An exception is thrown if, after whitespace is collapsed, the resulting sequence of characters is not in the lexical space defined by the intArray data type.
    
    These are the pre and post conditions of calling this method:
    - Precondition: the current event is either START_ELEMENT, or a textual event (CHARACTERS, CDATA), or END_ELEMENT (END_ELEMENT is allowed for convenience; if so, no read operation is tried, and -1 is returned immediately
    - Postcondition: the current event is the corresponding END_ELEMENT or CHARACTERS if only a portion of the array has been copied thus far.
    This method can be called multiple times until the cursor is positioned at the corresponding END_ELEMENT event. Stated differently, after the method is called for the first time, the cursor will move and remain in the CHARACTERS position while there are more bytes available for reading.
    Specified by:
    
    readElementAsIntArray in interface TypedXMLStreamReader
    
    Parameters:
    value - The array in which to copy the ints.
    from - The index in the array from which copying starts.
    length - The maximun number of ints to copy. Minimum value is 1; others an IllegalArgumentException is thrown
    
    Returns:
    The number of ints actually copied which must be less or equal than length, but at least one if any ints found. If not, -1 is returned to signal end of ints to parse.
    
    Throws:
    
    XMLStreamException
  - readElementAsLongArray
```
public int readElementAsLongArray(long[] value,
                         int from,
                         int length)
                           throws XMLStreamException
```
    Specified by:
    
    readElementAsLongArray in interface TypedXMLStreamReader
    
    Throws:
    
    XMLStreamException
  - readElementAsFloatArray
```
public int readElementAsFloatArray(float[] value,
                          int from,
                          int length)
                            throws XMLStreamException
```
    Specified by:
    
    readElementAsFloatArray in interface TypedXMLStreamReader
    
    Throws:
    
    XMLStreamException
  - readElementAsDoubleArray
```
public int readElementAsDoubleArray(double[] value,
                           int from,
                           int length)
                             throws XMLStreamException
```
    Specified by:
    
    readElementAsDoubleArray in interface TypedXMLStreamReader
    
    Throws:
    
    XMLStreamException
  - readElementAsArray
```
public int readElementAsArray(TypedArrayDecoder tad)
                       throws XMLStreamException
```
    Description copied from interface: TypedXMLStreamReader
    Read an element content as an array of tokens. This is done by reader tokenizing textual content by white space, and sending each token to specified decoder for decoding. This is repeated as long as element content has more tokens and decoder can accept more values.
    These are the pre- and post-conditions of calling this method:
    - Precondition: the current event is either START_ELEMENT, or a textual event (CHARACTERS, CDATA), or END_ELEMENT (END_ELEMENT is allowed for convenience; if so, no read operation is tried, and -1 is returned immediately
    - Postcondition: the current event is the corresponding END_ELEMENT or CHARACTERS if only a portion of the array has been copied thus far.
    This method can be called multiple times until the cursor is positioned at the corresponding END_ELEMENT event. Stated differently, after the method is called for the first time, the cursor will move and remain in the CHARACTERS position while there are more bytes available for reading.
    
    Note: passed decoder must accept at least one value, reader will not verify capacity before calling it with the first token.
    Specified by:
    
    readElementAsArray in interface TypedXMLStreamReader
    
    Returns:
    Number of elements decoded, or -1 to indicate that there was no more element content tokens to decode.
    
    Throws:
    
    XMLStreamException
  - readElementAsBinary
```
public int readElementAsBinary(byte[] resultBuffer,
                      int offset,
                      int maxLength)
                        throws XMLStreamException
```
    Specified by:
    
    readElementAsBinary in interface TypedXMLStreamReader
    
    Throws:
    
    XMLStreamException
  - readElementAsBinary
```
public int readElementAsBinary(byte[] resultBuffer,
                      int offset,
                      int maxLength,
                      Base64Variant v)
                        throws XMLStreamException
```
    Description copied from interface: TypedXMLStreamReader
    Read element content as decoded byte sequence; possibly only reading a fragment of all element content. The lexical representation of a byte array is defined by the XML Schema base64Binary data type. Whitespace MUST be collapsed according to the whiteSpace facet for the XML Schema base64Binary data type. An exception is thrown if content is not in the lexical space defined by the XML Schema base64Binary data type.
    Each call will read at least one decoded byte (and no more than the specified maximum length), if there is any content remaining. If none is available and END_ELEMENT is encountered, -1 is returned.
    These are the pre and post conditions of calling this method:
    - Precondition: the current event is either START_ELEMENT, or a textual event (CHARACTERS, CDATA), or END_ELEMENT (END_ELEMENT is allowed for convenience; if so, no read operation is tried, and -1 is returned immediately
    - Postcondition: the current event is the corresponding END_ELEMENT, if all remaining binary content was read, or CHARACTERS if only a portion of the array was read
    Additionally, caller MUST start decoding at START_ELEMENT; if the first decode calls is at CHARACTERS or CDATA event, results are not defined: result may be an exception, or invalid data being returned. Implementations are encouraged to throw an exception if possible, to make it easier to figure out the problem.
    This method can be called multiple times until the cursor is positioned at the corresponding END_ELEMENT event. Stated differently, after the method is called for the first time, the cursor will move and remain in the CHARACTERS position while there are potentially more bytes available for reading.
    Specified by:
    
    readElementAsBinary in interface TypedXMLStreamReader
    
    Parameters:
    resultBuffer - Array in which to copy decoded bytes.
    offset - Starting offset of the first decoded byte within result buffer
    maxLength - Maximun number of bytes to decode with this call
    
    Returns:
    The number of bytes actually decoded and returned, if any were available; -1 if there is no more content. If any content was copied, value must be less or equal than maxLength Note that this value is not guaranteed to equal maxLength even if enough content was available; that is, implementations can return shorter sections if they choose to, down to and including returning zero (0) if it was not possible to decode a full base64 triplet (3 output bytes from 4 input characters).
    
    Throws:
    
    XMLStreamException
  - getAttributeIndex
```
public int getAttributeIndex(String namespaceURI,
                    String localName)
```
    Description copied from interface: TypedXMLStreamReader
    
    Returns the index of the attribute whose local name is localName and URI is namespaceURI or -1 if no such attribute exists.
    
    Specified by:
    
    getAttributeIndex in interface TypedXMLStreamReader
    
    Parameters:
    namespaceURI - The attribute's namespace URI. Values of null and "" are considered the same, i.e. "no namespace" (or "empty" namespace)
    localName - The attribute's local name.
    
    Returns:
    The attribute's index or -1 if no such attribute exists.
  - getAttributeAsBoolean
```
public boolean getAttributeAsBoolean(int index)
                              throws XMLStreamException
```
    Description copied from interface: TypedXMLStreamReader
    
    Read an attribute value as a boolean. The lexical representation of a boolean is defined by the XML Schema boolean data type. Whitespace MUST be collapsed according to the whiteSpace facet for the XML Schema boolean data type. An exception is thrown if, after whitespace is collapsed, the resulting sequence of characters is not in the lexical space defined by the XML Schema boolean data type.
    
    Specified by:
    
    getAttributeAsBoolean in interface TypedXMLStreamReader
    
    Parameters:
    index - The attribute's index as returned by TypedXMLStreamReader.getAttributeIndex(String, String)
    
    Throws:
    
    XMLStreamException - If unable to convert the resulting character sequence into an XML Schema boolean value.
  - getAttributeAsInt
```
public int getAttributeAsInt(int index)
                      throws XMLStreamException
```
    Description copied from interface: TypedXMLStreamReader
    
    Read an attribute value as a boolean. The lexical representation of a boolean is defined by the XML Schema integer data type. Whitespace MUST be collapsed according to the whiteSpace facet for the type. An exception is thrown if, after whitespace is collapsed, the resulting sequence of characters is not in the lexical space defined by the XML Schema integer data type.
    
    Specified by:
    
    getAttributeAsInt in interface TypedXMLStreamReader
    
    Parameters:
    index - The attribute's index as returned by TypedXMLStreamReader.getAttributeIndex(String, String)
    
    Throws:
    
    XMLStreamException - If unable to convert the resulting character sequence into an XML Schema boolean value.
  - getAttributeAsLong
```
public long getAttributeAsLong(int index)
                        throws XMLStreamException
```
    Description copied from interface: TypedXMLStreamReader
    
    Read an attribute value as a boolean. The lexical representation of a boolean is defined by the XML Schema long data type. Whitespace MUST be collapsed according to the whiteSpace facet for the type. An exception is thrown if, after whitespace is collapsed, the resulting sequence of characters is not in the lexical space defined by the XML Schema long data type.
    
    Specified by:
    
    getAttributeAsLong in interface TypedXMLStreamReader
    
    Parameters:
    index - The attribute's index as returned by TypedXMLStreamReader.getAttributeIndex(String, String)
    
    Throws:
    
    XMLStreamException - If unable to convert the resulting character sequence into an XML Schema boolean value.
  - getAttributeAsFloat
```
public float getAttributeAsFloat(int index)
                          throws XMLStreamException
```
    Specified by:
    
    getAttributeAsFloat in interface TypedXMLStreamReader
    
    Throws:
    
    XMLStreamException
  - getAttributeAsDouble
```
public double getAttributeAsDouble(int index)
                            throws XMLStreamException
```
    Specified by:
    
    getAttributeAsDouble in interface TypedXMLStreamReader
    
    Throws:
    
    XMLStreamException
  - getAttributeAsInteger
```
public BigInteger getAttributeAsInteger(int index)
                                 throws XMLStreamException
```
    Specified by:
    
    getAttributeAsInteger in interface TypedXMLStreamReader
    
    Throws:
    
    XMLStreamException
  - getAttributeAsDecimal
```
public BigDecimal getAttributeAsDecimal(int index)
                                 throws XMLStreamException
```
    Specified by:
    
    getAttributeAsDecimal in interface TypedXMLStreamReader
    
    Throws:
    
    XMLStreamException
  - getAttributeAsQName
```
public QName getAttributeAsQName(int index)
                          throws XMLStreamException
```
    Specified by:
    
    getAttributeAsQName in interface TypedXMLStreamReader
    
    Throws:
    
    XMLStreamException
  - getAttributeAs
```
public final void getAttributeAs(int index,
                  TypedValueDecoder tvd)
                          throws XMLStreamException
```
    Description copied from interface: TypedXMLStreamReader
    
    Generic access method that can be used for efficient decoding of additional types not support natively by the typed stream reader. The main benefit of using this method is that the stream reader can efficient gather all textual content necessary and pass it to the decoder, often avoiding construction of intemediate Strings.
    As with TypedXMLStreamReader.getElementAs(org.codehaus.stax2.typed.TypedValueDecoder), value passed to a decode method will be trimmed of any leading or trailing white space.
    
    Specified by:
    
    getAttributeAs in interface TypedXMLStreamReader
    
    Throws:
    
    XMLStreamException
  - getAttributeAsIntArray
```
public int[] getAttributeAsIntArray(int index)
                             throws XMLStreamException
```
    Description copied from interface: TypedXMLStreamReader
    Read an attribute content as an int array. The lexical representation of a int array is defined by the following XML schema type:
```
    <xs:simpleType name="intArray">
       <xs:list itemType="xs:int"/>
    </xs:simpleType>
```
    whose lexical space is a list of space-separated ints. Whitespace MUST be collapsed according to the whiteSpace facet for the intArray type shown above. An exception is thrown if, after whitespace is collapsed, the resulting sequence of characters is not in the lexical space defined by the intArray data type.
    Specified by:
    
    getAttributeAsIntArray in interface TypedXMLStreamReader
    
    Parameters:
    index - The attribute's index as returned by TypedXMLStreamReader.getAttributeIndex(String, String).
    
    Returns:
    An array of ints with the content.
    
    Throws:
    
    XMLStreamException - If unable to convert the resulting character sequence into an XML Schema boolean value.
  - getAttributeAsLongArray
```
public long[] getAttributeAsLongArray(int index)
                               throws XMLStreamException
```
    Specified by:
    
    getAttributeAsLongArray in interface TypedXMLStreamReader
    
    Throws:
    
    XMLStreamException
  - getAttributeAsFloatArray
```
public float[] getAttributeAsFloatArray(int index)
                                 throws XMLStreamException
```
    Specified by:
    
    getAttributeAsFloatArray in interface TypedXMLStreamReader
    
    Throws:
    
    XMLStreamException
  - getAttributeAsDoubleArray
```
public double[] getAttributeAsDoubleArray(int index)
                                   throws XMLStreamException
```
    Specified by:
    
    getAttributeAsDoubleArray in interface TypedXMLStreamReader
    
    Throws:
    
    XMLStreamException
  - getAttributeAsArray
```
public int getAttributeAsArray(int index,
                      TypedArrayDecoder tad)
                        throws XMLStreamException
```
    Description copied from interface: TypedXMLStreamReader
    
    Method that allows reading contents of an attribute as an array of whitespace-separate tokens, decoded using specified decoder.
    
    Specified by:
    
    getAttributeAsArray in interface TypedXMLStreamReader
    
    Returns:
    Number of tokens decoded, 0 if none found
    
    Throws:
    
    XMLStreamException
  - _getAttributeAsArray
```
protected int _getAttributeAsArray(TypedArrayDecoder tad,
                       String attrValue)
                            throws XMLStreamException
```
    Throws:
    
    XMLStreamException
  - getAttributeAsBinary
```
public byte[] getAttributeAsBinary(int index)
                            throws XMLStreamException
```
    Description copied from interface: TypedXMLStreamReader
    
    Read an attribute value as a byte array. The lexical representation of a byte array is defined by the XML Schema base64Binary data type. Whitespace MUST be collapsed according to the whiteSpace facet for the XML Schema base64Binary data type. An exception is thrown if, after whitespace is collapsed, the resulting sequence of characters is not in the lexical space defined by the XML Schema base64Binary data type.
    
    Specified by:
    
    getAttributeAsBinary in interface TypedXMLStreamReader
    
    Parameters:
    index - The attribute's index as returned by TypedXMLStreamReader.getAttributeIndex(String, String).
    
    Returns:
    An array of bytes with the content.
    
    Throws:
    
    XMLStreamException - If unable to convert the resulting character sequence into an XML Schema boolean value.
  - getAttributeAsBinary
```
public byte[] getAttributeAsBinary(int index,
                          Base64Variant v)
                            throws XMLStreamException
```
    Specified by:
    
    getAttributeAsBinary in interface TypedXMLStreamReader
    
    Throws:
    
    XMLStreamException
  - getFeature
```
public Object getFeature(String name)
```
    Description copied from interface: XMLStreamReader2
    
    Method that can be used to get per-reader values; both generic ones (names for which are defined as constants in this class), and implementation dependant ones.
    Note: although some feature names are shared with XMLStreamReader2.setFeature(java.lang.String, java.lang.Object), not all are: some features are read-only, some write-only
    
    Specified by:
    
    getFeature in interface XMLStreamReader2
    
    Parameters:
    name - Name of the feature of which value to get
    
    Returns:
    Value of the feature (possibly null), if supported; null otherwise
  - setFeature
```
public void setFeature(String name,
              Object value)
```
    Description copied from interface: XMLStreamReader2
    
    Method that can be used to set per-reader features such as configuration settings; both generic ones (names for which are defined as constants in this class), and implementation dependant ones.
    Note: although some feature names are shared with XMLStreamReader2.getFeature(java.lang.String), not all are: some features are read-only, some write-only
    
    Specified by:
    
    setFeature in interface XMLStreamReader2
    
    Parameters:
    name - Name of the feature to set
    value - Value to set feature to.
  - skipElement
```
public void skipElement()
                 throws XMLStreamException
```
    Description copied from interface: XMLStreamReader2
    
    Method that will skip all the contents of the element that the stream currently points to. Current event when calling the method has to be START_ELEMENT (or otherwise IllegalStateException is thrown); after the call the stream will point to the matching END_ELEMENT event, having skipped zero or more intervening events for the contents.
    
    Specified by:
    
    skipElement in interface XMLStreamReader2
    
    Throws:
    
    XMLStreamException
  - getAttributeInfo
```
public AttributeInfo getAttributeInfo()
                               throws XMLStreamException
```
    Description copied from interface: XMLStreamReader2
    
    Method that can be called to get additional information about attributes related to the current start element, as well as related DTD-based information if available. Note that the reader has to currently point to START_ELEMENT; if not, a IllegalStateException will be thrown.
    
    Specified by:
    
    getAttributeInfo in interface XMLStreamReader2
    
    Throws:
    
    XMLStreamException
  - findAttributeIndex
```
public int findAttributeIndex(String nsURI,
                     String localName)
```
    Specified by:
    
    findAttributeIndex in interface AttributeInfo
    
    Returns:
    Index of the specified attribute, if the current element has such an attribute (explicit, or one created via default value expansion); -1 if not.
  - getIdAttributeIndex
```
public int getIdAttributeIndex()
```
    Description copied from interface: AttributeInfo
    
    Returns the index of the id attribute (attribute with any name, type ID from DTD) of current (start) element, if any. Note that DTD only allows at most one such attribute per element.
    
    Specified by:
    
    getIdAttributeIndex in interface AttributeInfo
    
    Returns:
    Index of the ID attribute of current element, if the current element has such an attribute defined; -1 if not.
  - getNotationAttributeIndex
```
public int getNotationAttributeIndex()
```
    Description copied from interface: AttributeInfo
    
    Returns the index of the notation attribute (attribute with any name, type NOTATION from DTD) of current (start) element, if any. Note that DTD only allows at most one such attribute per element.
    
    Specified by:
    
    getNotationAttributeIndex in interface AttributeInfo
    
    Returns:
    Index of the NOTATION attribute of current element, if the current element has such an attribute defined; -1 if not.
  - getDTDInfo
```
public DTDInfo getDTDInfo()
                   throws XMLStreamException
```
    Since this class implements DTDInfo, method can just return this.
    
    Specified by:
    
    getDTDInfo in interface XMLStreamReader2
    
    Returns:
    Information object for accessing further DOCTYPE information, iff the reader currently points to DTD event, AND is operating in mode that parses such information (DTD-aware at least, and usually also validating)
    
    Throws:
    
    XMLStreamException
  - getLocationInfo
```
public final LocationInfo getLocationInfo()
```
    Location information is always accessible, for this reader.
    
    Specified by:
    
    getLocationInfo in interface XMLStreamReader2
  - getText
```
public int getText(Writer w,
          boolean preserveContents)
            throws IOException,
                   XMLStreamException
```
    Method similar to getText(), except that it just uses provided Writer to write all textual content. For further optimization, it may also be allowed to do true pass-through, thus possibly avoiding one temporary copy of the data.
    TODO: try to optimize to allow completely streaming pass-through: currently will still read all data in memory buffers before outputting
    
    Specified by:
    
    getText in interface XMLStreamReader2
    
    Parameters:
    w - Writer to use for writing textual contents
    preserveContents - If true, reader has to preserve contents so that further calls to getText will return proper conntets. If false, reader is allowed to skip creation of such copies: this can improve performance, but it also means that further calls to getText is not guaranteed to return meaningful data.
    
    Returns:
    Number of characters written to the reader
    
    Throws:
    
    IOException
    
    XMLStreamException
  - getDepth
```
public int getDepth()
```
    Description copied from interface: XMLStreamReader2
    
    Method that returns the number of open elements in the stack; 0 when the reader is in prolog/epilog, 1 inside root element (including when pointing at the root element itself) and so on. Depth is same for matching start/end elements, as well as for the all children of an element.
    
    Specified by:
    
    getDepth in interface XMLStreamReader2
    
    Returns:
    Number of open elements in the stack; 0 when parser is in prolog/epilog, 1 inside root element and so on.
  - isEmptyElement
```
public boolean isEmptyElement()
                       throws XMLStreamException
```
    Description copied from interface: XMLStreamReader2
    
    Method that can be used to check whether current START_ELEMENT event was created for an empty element (xml short-hand notation where one tag implies start and end, ending with "/>"), or not.
    Note: method may need to read more data to know if the element is an empty one, and as such may throw an i/o or parsing exception (as XMLStreamException); however, it won't throw exceptions for non-START_ELEMENT event types.
    
    Specified by:
    
    isEmptyElement in interface XMLStreamReader2
    
    Returns:
    True, if cursor points to a start or end element that is constructed from 'empty' element (ends with '/>'); false otherwise.
    
    Throws:
    
    XMLStreamException
  - getNonTransientNamespaceContext
```
public NamespaceContext getNonTransientNamespaceContext()
```
    Description copied from interface: XMLStreamReader2
    
    This method returns a namespace context object that contains information identical to that returned by XMLStreamReader.getNamespaceContext(), but one that is not transient. That is, one that will remain valid and unchanged after its creation. This allows the namespace context to be used independent of its source documents life cycle. One possible use case is to use this namespace context for 'initializing' writers (especially ones that use repairing mode) with optimal/preferred name space bindings.
    
    Specified by:
    
    getNonTransientNamespaceContext in interface XMLStreamReader2
    
    Returns:
    Non-transient namespace context as explained above.
  - getPrefixedName
```
public String getPrefixedName()
```
    Description copied from interface: XMLStreamReader2
    
    This method returns "prefix-qualified" name of the current element. In general, this means character-by-character exact name of the element in XML content, and may be useful in informational purposes, as well as when interacting with packages and APIs that use such names (such as what SAX may use as qnames).
    Note: implementations are encouraged to provide an implementation that would be more efficient than calling getLocalName and getPrefix separately, but are not required to do so. Nonetheless it is usually at least as efficient (if not more) to call this method as to do it fully in calling code.
    
    Specified by:
    
    getPrefixedName in interface XMLStreamReader2
    
    Returns:
    Prefix-qualified name of the current element; essentially 'prefix:localName' if the element has a prefix, or 'localName' if it does not have one (belongs to the default namespace)
  - closeCompletely
```
public void closeCompletely()
                     throws XMLStreamException
```
    Description copied from interface: XMLStreamReader2
    
    Method similar to XMLStreamReader.close(), except that this method also does close the underlying input source if it has not yet been closed. It is generally preferable to call this method if the parsing ends in an exception; and for some input sources (when passing a File or URL for factory method) it has to be called as the application does not have access to the actually input source (InputStream opened from a URL and so on).
    
    Specified by:
    
    closeCompletely in interface XMLStreamReader2
    
    Throws:
    
    XMLStreamException
  - getProcessedDTD
```
public Object getProcessedDTD()
```
    Specified by:
    
    getProcessedDTD in interface DTDInfo
    
    Returns:
    If current event is DTD, DTD support is enabled, and reader supports DTD processing, returns an internal Object implementation uses for storing/processing DTD; otherwise returns null.
  - getDTDRootName
```
public String getDTDRootName()
```
    Specified by:
    
    getDTDRootName in interface DTDInfo
    
    Returns:
    If current event is DTD, returns the full root name (including prefix, if any); otherwise returns null
  - getDTDPublicId
```
public String getDTDPublicId()
```
    Specified by:
    
    getDTDPublicId in interface DTDInfo
    
    Returns:
    If current event is DTD, and has a public id, returns the public id; otherwise returns null.
  - getDTDSystemId
```
public String getDTDSystemId()
```
    Specified by:
    
    getDTDSystemId in interface DTDInfo
    
    Returns:
    If current event is DTD, and has a system id, returns the system id; otherwise returns null.
  - getDTDInternalSubset
```
public String getDTDInternalSubset()
```
    Specified by:
    
    getDTDInternalSubset in interface DTDInfo
    
    Returns:
    Internal subset portion of the DOCTYPE declaration, if any; empty String if none
  - getProcessedDTDSchema
```
public DTDValidationSchema getProcessedDTDSchema()
```
    Description copied from interface: DTDInfo
    
    Method similar to DTDInfo.getProcessedDTD(), but type-safe. Will return the DTD schema instance that was read, if we are in mode where it does get read (at least dtd-aware).
    
    Specified by:
    
    getProcessedDTDSchema in interface DTDInfo
  - getStartingByteOffset
```
public long getStartingByteOffset()
```
    Description copied from interface: LocationInfo
    
    Method that can be used to get exact byte offset (number of bytes read from the stream right before getting to this location) in the stream that is pointed to by this reader, right before the start of the current event.
    Note: this value MAY be the same as the one returned by LocationInfo.getStartingCharOffset(), but usually only for single-byte character streams (Ascii, ISO-Latin).
    
    Specified by:
    
    getStartingByteOffset in interface LocationInfo
    
    Returns:
    Byte offset (== number of bytes reader so far) within the underlying stream, if the stream and stream reader are able to provide this (separate from the character offset, for variable-byte encodings); -1 if not.
  - getStartingCharOffset
```
public long getStartingCharOffset()
```
    Description copied from interface: LocationInfo
    
    Method that can be used to get exact character offset (number of chars read from the stream right before getting to this location) in the stream that is pointed to by this reader, right before the start of the current event.
    Note: this value MAY be the same as the one returned by LocationInfo.getStartingByteOffset(); this is the case for single-byte character streams (Ascii, ISO-Latin), as well as for streams for which byte offset information is not available (Readers, Strings).
    
    Specified by:
    
    getStartingCharOffset in interface LocationInfo
    
    Returns:
    Character offset (== number of bytes reader so far) within the underlying stream, if the stream and stream reader are able to provide this (separate from byte offset, for variable-byte encodings); -1 if not.
  - getEndingByteOffset
```
public long getEndingByteOffset()
                         throws XMLStreamException
```
    Description copied from interface: LocationInfo
    
    Method that can be used to get exact byte offset (number of bytes read from the stream right before getting to this location) in the stream that is pointed to by this reader, right after the end of the current event.
    Note: this value MAY be the same as the one returned by LocationInfo.getEndingCharOffset(), but usually only for single-byte character streams (Ascii, ISO-Latin).
    Note: for lazy-loading implementations, calling this method may require the underlying stream to be advanced and contents parsed; this is why it is possible that an exception be thrown.
    
    Specified by:
    
    getEndingByteOffset in interface LocationInfo
    
    Returns:
    Byte offset (== number of bytes reader so far) within the underlying stream, if the stream and stream reader are able to provide this (separate from the character offset, for variable-byte encodings); -1 if not.
    
    Throws:
    
    XMLStreamException
  - getEndingCharOffset
```
public long getEndingCharOffset()
                         throws XMLStreamException
```
    Description copied from interface: LocationInfo
    
    Method that can be used to get exact character offset (number of chars read from the stream right before getting to this location) in the stream that is pointed to by this reader, right after the end of the current event.
    Note: this value MAY be the same as the one returned by LocationInfo.getEndingByteOffset(); this is the case for single-byte character streams (Ascii, ISO-Latin), as well as for streams for which byte offset information is not available (Readers, Strings).
    Note: for lazy-loading implementations, calling this method may require the underlying stream to be advanced and contents parsed; this is why it is possible that an exception be thrown.
    
    Specified by:
    
    getEndingCharOffset in interface LocationInfo
    
    Returns:
    Character offset (== number of bytes reader so far) within the underlying stream, if the stream and stream reader are able to provide this (separate from byte offset, for variable-byte encodings); -1 if not.
    
    Throws:
    
    XMLStreamException
  - getStartLocation
```
public XMLStreamLocation2 getStartLocation()
```
    Description copied from interface: LocationInfo
    
    An optional method that either returns the location object that points the starting position of the current event, or null if implementation does not keep track of it (some may return only end location; and some no location at all).
    Note: since it is assumed that the start location must either have been collected by now, or is not accessible (i.e. implementation [always] returns null), no exception is allowed to be throws, as no parsing should ever need to be done (unlike with LocationInfo.getEndLocation()).
    
    Specified by:
    
    getStartLocation in interface LocationInfo
    
    Returns:
    Location of the first character of the current event in the input source (which will also be the starting location of the following event, if any, or EOF if not), or null (if implementation does not track locations).
  - getCurrentLocation
```
public XMLStreamLocation2 getCurrentLocation()
```
    Description copied from interface: LocationInfo
    
    A method that returns the current location of the stream reader at the input source. This is somewhere between the start and end locations (inclusive), depending on how parser does it parsing (for non-lazy implementations it's always the end location; for others something else).
    Since this location information should always be accessible, no further parsing is to be done, and no exceptions can be thrown.
    
    Specified by:
    
    getCurrentLocation in interface LocationInfo
    
    Returns:
    Location of the next character reader will parse in the input source.
  - getEndLocation
```
public final XMLStreamLocation2 getEndLocation()
                                        throws XMLStreamException
```
    Description copied from interface: LocationInfo
    
    An optional method that either returns the location object that points the ending position of the current event, or null if implementation does not keep track of it (some may return only start location; and some no location at all).
    Note: since some implementations may not yet know the end location (esp. ones that do lazy loading), this call may require further parsing. As a result, this method may throw a parsing or I/O errors.
    
    Specified by:
    
    getEndLocation in interface LocationInfo
    
    Returns:
    Location right after the end of the current event (which will also be the start location of the next event, if any, or of EOF otherwise).
    
    Throws:
    
    XMLStreamException - If the stream reader had to advance to the end of the event (to find the location), it may encounter a parsing (or I/O) error; if so, that gets thrown
  - validateAgainst
```
public XMLValidator validateAgainst(XMLValidationSchema schema)
                             throws XMLStreamException
```
    Description copied from interface: Validatable
    
    Method that will construct a XMLValidator instance from the given schema (unless a validator for that schema has already been added), initialize it if necessary, and make validatable object (reader, writer) call appropriate validation methods from this point on until the end of the document (that is, it's not scoped with sub-trees), or until validator is removed by an explicit call to Validatable.stopValidatingAgainst(org.codehaus.stax2.validation.XMLValidationSchema).
    Note that while this method can be called at any point in output processing, validator instances are not required to be able to handle addition at other points than right before outputting the root element.
    
    Specified by:
    
    validateAgainst in interface Validatable
    
    Returns:
    Validator instance constructed, if validator was added, or null if a validator for the schema has already been constructed.
    
    Throws:
    
    XMLStreamException
  - stopValidatingAgainst
```
public XMLValidator stopValidatingAgainst(XMLValidationSchema schema)
                                   throws XMLStreamException
```
    Description copied from interface: Validatable
    
    Method that can be called by application to stop validating output against a schema, for which Validatable.validateAgainst(org.codehaus.stax2.validation.XMLValidationSchema) was called earlier.
    
    Specified by:
    
    stopValidatingAgainst in interface Validatable
    
    Returns:
    Validator instance created from the schema that was removed, if one was in use; null if no such schema in use.
    
    Throws:
    
    XMLStreamException
  - stopValidatingAgainst
```
public XMLValidator stopValidatingAgainst(XMLValidator validator)
                                   throws XMLStreamException
```
    Description copied from interface: Validatable
    
    Method that can be called by application to stop validating output using specified validator. The validator passed should be an earlier return value for a call to Validatable.validateAgainst(org.codehaus.stax2.validation.XMLValidationSchema).
    Note: the specified validator is compared for identity with validators in use, not for equality.
    
    Specified by:
    
    stopValidatingAgainst in interface Validatable
    
    Returns:
    Validator instance found (ie. argument validator) if it was being used for validating current document; null if not.
    
    Throws:
    
    XMLStreamException
  - setValidationProblemHandler
```
public ValidationProblemHandler setValidationProblemHandler(ValidationProblemHandler h)
```
    Description copied from interface: Validatable
    
    Method that application can call to define a custom handler for validation problems encountered during validation process.
    
    Specified by:
    
    setValidationProblemHandler in interface Validatable
    
    Parameters:
    h - Handler to install, if non null; if null, indicates that the default (implementation-specific) handling should be used
    
    Returns:
    Previously set validation problem handler, if any; null if none was set
  - coalesceText
```
protected void coalesceText(int initialType)
```
  - reportWrongState
```
protected void reportWrongState(int errorType)
```
  - reportParseProblem
```
protected void reportParseProblem(int errorType)
                           throws XMLStreamException
```
    Throws:
    
    XMLStreamException
  - throwStreamException
```
protected void throwStreamException(String msg)
                             throws XMLStreamException
```
    Throws:
    
    XMLStreamException
  - getErrorLocation
```
protected Location getErrorLocation()
```
  - _constructTypeException
```
protected TypedXMLStreamException _constructTypeException(IllegalArgumentException iae,
                                              String lexicalValue)
```
    Method called to wrap or convert given conversion-fail exception into a full TypedXMLStreamException,
    
    Parameters:
    iae - Problem as reported by converter
    lexicalValue - Lexical value (element content, attribute value) that could not be converted succesfully.
  - _constructTypeException
```
protected TypedXMLStreamException _constructTypeException(String msg,
                                              String lexicalValue)
```
  - _decoderFactory
```
protected ValueDecoderFactory _decoderFactory()
```
  - _base64Decoder
```
protected StringBase64Decoder _base64Decoder()
```
  - findErrorDesc
```
protected String findErrorDesc(int errorType,
                   int currEvent)
```
    Method used to locate error message description to use. Calls sub-classes findErrorDesc() first, and only if no message found, uses default messages defined here.
  - _internName
```
protected String _internName(String name)
```
    Method called to do additional intern()ing for a name, if and as necessary
  - _internNsURI
```
protected String _internNsURI(String uri)
```

Class DOMWrappingReader

Field Summary

Fields inherited from interface org.codehaus.stax2.XMLStreamReader2

Fields inherited from interface javax.xml.stream.XMLStreamConstants

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

INT_SPACE

MASK_TYPED_ACCESS_BINARY

ERR_STATE_NOT_START_ELEM

ERR_STATE_NOT_ELEM

ERR_STATE_NOT_PI

ERR_STATE_NOT_TEXTUAL

ERR_STATE_NOT_TEXTUAL_XXX

ERR_STATE_NOT_TEXTUAL_OR_ELEM

ERR_STATE_NO_LOCALNAME

_systemId

_rootNode

_cfgNsAware

_coalescing

_cfgInternNames

_cfgInternNsURIs

_currEvent

_currNode

_depth

_coalescedText

_textBuffer

_attrList

_nsDeclList

_decoderFactory

_base64Decoder

Constructor Detail

DOMWrappingReader

Method Detail

setInternNames

setInternNsURIs

throwStreamException

getCharacterEncodingScheme

getEncoding

getVersion

isStandalone

standaloneSet

getProperty

isPropertySupported

setProperty

getAttributeCount

getAttributeLocalName

getAttributeName

getAttributeNamespace

getAttributePrefix

getAttributeType

getAttributeValue

getAttributeValue

getElementText

getEventType

getLocalName

getLocation

getName

getNamespaceContext

getNamespaceCount

getNamespacePrefix

getNamespaceURI

getNamespaceURI

getPIData

getPITarget

getPrefix

getText

getTextCharacters

getTextCharacters

getTextLength

getTextStart

hasName

hasNext

hasText

isAttributeSpecified

isCharacters

isEndElement

isStartElement

isWhiteSpace