Package org.codehaus.stax2.ri

Class Stax2ReaderImpl

    • Field Detail

      • _decoderFactory

        protected ValueDecoderFactory _decoderFactory
        Factory used for constructing decoders we need for typed access

    • Constructor Detail

      • Stax2ReaderImpl

        protected Stax2ReaderImpl()

    • Method Detail

      • getFeature

        @Deprecated
public Object getFeature​(String name)
        Deprecated.
        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

        @Deprecated
public void setFeature​(String name,
                       Object value)
        Deprecated.
        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.

      • isPropertySupported

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

      • 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

      • getDTDInfo

        public DTDInfo getDTDInfo()
                   throws XMLStreamException
        Description copied from interface: XMLStreamReader2
        Method that can be called to get information about DOCTYPE declaration that the reader is currently pointing to, if the reader has parsed it. Implementations can also choose to return null to indicate they do not provide extra information; but they should not throw any exceptions beyond normal parsing exceptions.
        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

      • getText

        public int getText​(Writer w,
                   boolean preserveContents)
            throws IOException,
                   XMLStreamException
        Description copied from interface: XMLStreamReader2
        Method similar to XMLStreamReader.getText(), except that it just uses provided Writer to write all textual content, and that it works for wider range of event types. For further optimization, it may also be allowed to do true pass-through, thus possibly avoiding one temporary copy of the data. Finally, note that this method is also guaranteed NOT to return fragments, even when coalescing is not enabled and a parser is otherwised allowed to return partial segments: this requirement is due to there being little benefit in returning such short chunks when streaming. Coalescing property is still honored normally.

        Method can only be called on states CDATA, CHARACTERS, COMMENT, DTD, ENTITY_REFERENCE, SPACE and PROCESSING_INSTRUCTION; if called when reader is in another state, IllegalStateException will be thrown. Content written for elements is same as with XMLStreamReader.getText().

        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 abstract 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 abstract 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 current event is START_ELEMENT and is based on a parsed empty element; otherwise false
        Throws:
        XMLStreamException

      • getNonTransientNamespaceContext

        public abstract 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

      • 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.

      • 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

      • 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 abstract 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 abstract 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 abstract 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

      • setValidationProblemHandler

        public abstract 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

      • 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

      • 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

      • getAttributeIndex

        public abstract 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.

      • 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.

      • 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.

      • throwNotStartElem

        protected void throwNotStartElem()