All Classes

Class	Description
AaltoInputProperties	Class that contains constant for property names used to configure cursor and event readers produced by Aalto implementation of XMLInputFactory.
AsciiXmlWriter	This is the generic implementation of XmlWriter, used if the destination is byte-based OutputStream, and encoding is 7-bit (US) Ascii.
AsyncByteArrayFeeder
AsyncByteArrayScanner	This is the base class for asynchronous (non-blocking) XML scanners.
AsyncByteBufferFeeder
AsyncByteBufferScanner	This is the base class for asynchronous (non-blocking) XML scanners.
AsyncByteScanner
AsyncInputFeeder	Interface used by AsyncXMLStreamReader to get more input to parse.
AsyncStreamReaderImpl<F extends AsyncInputFeeder>	Implementation of AsyncXMLStreamReader.
AsyncXmlDeclHelper	Helper class that contains specialized decode methods for pseudo-attributes contained in XML declaration.
AsyncXMLInputFactory	Extension of XMLInputFactory2 to provide factory methods for constructing non-blocking (asynchronous) parsers (of type AsyncXMLStreamReader.
AsyncXMLStreamReader<F extends AsyncInputFeeder>	Extension of XMLStreamReader2 used by non-blocking ("async") stream readers.
AttributeCollector	Object used by the tokenizer to collect and store information about attributes, specifically, names and values.
BijectiveNsMap	Helper class that implements "bijective map" (Map that allows use of values as keys and vice versa, bidirectional access), and is specifically used for storing namespace binding information.
BufferRecycler	This is a small utility class, whose main functionality is to allow simple reuse of raw byte/char buffers.
ByteBasedPName	This intermediate abstract class defines more specialized API needed by components like symbol tables, which need to provide efficient access to byte-based PNames.
ByteBasedPNameFactory	Simple factory that can instantiate appropriate PName instances, given input data to use for construction.
ByteBasedPNameTable	This is a symbol table implementation used for storing byte-based PNames, specifically, instances of (ByteBasedPName).
ByteBasedScanner	Intermediate base class used by different byte-backed scanners.
ByteSourceBootstrapper	Class that takes care of bootstrapping main document input from a byte-oriented input source: usually either an InputStream, or a block source like byte array.
ByteWName	This class is used to represent all names that are to be serialized to byte streams, independent of specific encoding used (they will be stored on per-encoding symbol tables however).
ByteXmlWriter	This abstract base class (partial implementation of XmlWriter) is used if the destination is byte-based OutputStream.
CharBasedPNameTable	This is a symbol table implementation used for storing byte-based PNames, specifically, instances of (PNameC).
CharsetNames	Simple utility class that normalizes given character input character set names into canonical (within context of this processor) names
CharSourceBootstrapper	Class that takes care of bootstrapping main document input from a Stream input source.
CharXmlWriter	This is the generic implementation of XmlWriter, used if the destination is a character based, like a Writer.
CommonConfig	Base class for reader and writer-side configuration/context objects
DataUtil
DOMOutputElement	Context object that holds information about an open element (one for which START_ELEMENT has been sent, but no END_ELEMENT)
DOMReaderImpl	Concrete DOM-backed implementation, based on the Stax2 reference implementation's default implementation.
DOMWriterImpl	This is an adapter class that allows building a DOM tree using XMLStreamWriter interface.
ElementScope	Simple container of information about an open element (one for which start tag has been seen, but not yet end; or, for empty tags, START_ELEMENT has been returned but END_ELEMENT not yet)
EmptyIterator<T>	Simple implementation of "null iterator", iterator that has nothing to iterate over.
EntityNames
ErrorConsts	This class contains various String constants used for error reporting.
EventAllocatorImpl	Specialized event allocator implementation.
EventFactoryImpl	Simple event factory implementation, mostly based on the reference implementation included in Stax2 API jar.
EventReaderImpl	Simple implementation based on Stax2 reference implementation base.
FixedNsContext	Non-transient implementation of NamespaceContext.
IllegalCharHandler
IllegalCharHandler.ReplacingIllegalCharHandler
IncompleteEvent	Bogus XMLEvent returned when the next event is not yet available, in case of non-blocking (async) parsing.
InputBootstrapper	Abstract base class that defines shared functionality between different bootstrappers (byte stream, char Readers, block input)
InputCharTypes
InputFactoryImpl	Aalto implementation of basic Stax factory (both XMLInputFactory and XMLInputFactory2) as well as API for producing non-blocking (async) parsers (that is, AsyncXMLInputFactory).
IoStreamException	Simple wrapper for IOExceptions; needed when StAX does not expose underlying I/O exceptions via its methods.
Latin1XmlWriter	This is the generic implementation of XmlWriter, used if the destination is byte-based OutputStream, and encoding is ISO-8859-1 (aka Latin1)
LocationImpl	Basic implementation of XMLStreamLocation2, used by stream readers and writers.
MergedStream	Simple InputStream implementation that is used to "unwind" some data previously read from an input stream; so that as long as some of that data remains, it's returned; but as long as it's read, we'll just use data from the underlying original stream.
NameTable	This class defines the basic high-level interface for symbol table implementations, especially regarding how they are obtained and reused.
NonRepairingStreamWriter	Concrete implementation of StreamWriterBase, which implements basic namespace-aware, non repairing functionality.
NsDeclaration	This class encapsulates information about a namespace binding declaration, associated with start elements.
OutputCharTypes
OutputElementBase	Class that encapsulates information about a specific element in virtual output stack for namespace-aware writers.
OutputFactoryImpl	Basic implementation of XMLOutputFactory.
PName	Prefixed Name is similar to QName (qualified name), but only contains information about local name optionally prefixed by a prefix and colon, without namespace binding information.
PName1	Specialized implementation of PName: can be used for short Strings that consists of at most 4 bytes.
PName2	Specialized implementation of PName: can be used for short Strings that consists of at most 8 bytes.
PName3	Specialized implementation of PName: can be used for medium-sized Strings that consists of at most 9-12 bytes.
PNameC	An alternate implementation of PName: instead of coming straight from byte contents, it is actually just built from a character array.
PNameN	General implementation of PName to be used with longer names (ones that consist of more than 8 bytes).
ReaderConfig	This is the shared configuration object passed by the factory to reader, and by reader to whoever needs it (scanners at least).
ReaderScanner	This is the concrete scanner implementation used when input comes as a Reader.
RepairingStreamWriter	Concrete implementation of StreamWriterBase, which implements the "namespace repairing" mode of operation.
SAXFeature	Enumeration for listing all currently (SAX 2.0.2) defined standard features
SAXParserFactoryImpl	This is implementation of the main JAXP SAX factory, and as such acts as the entry point from JAXP.
SAXProperty	Enumeration for listing all currently (SAX 2.0.2) defined standard properties.
SAXUtil	Container for utility methods needed by the parser factory, or parser wrapper components.
SingleByteXmlWriter	This is the common base class for writers that output to byte-backed output sources, and use Ascii or ISO-8859-1 (Latin1) encoding.
SingletonIterator	Simple read-only iterator that iterators over one specific item, passed in as constructor argument.
StreamExceptionBase	Base class for all XMLStreamException instances that we use.
StreamReaderImpl	Basic backend-independent XMLStreamReader implementation.
StreamScanner	Base class for various byte stream based scanners (generally one for each type of encoding supported).
StreamWriterBase	Base class for XMLStreamReader implementations.
StreamWriterBase.State
TextAccumulator	Simple utility class used to efficiently accumulate and concatenate text passed in various forms
TextBuilder	Class conceptually similar to StringBuilder, but that allows for bit more efficient building, using segmented internal buffers, and direct access to these buffers.
TextUtil
UncheckedStreamException	Unchecked exception that has to be used for methods of Stax API that do not allow throwing checked XMLStreamException, but where internal methods that need to be called may throw such an exception.
UriCanonicalizer	This class is used for canonicalization of namespace URIs.
URLUtil
Utf32Reader	Since JDK does not come with UTF-32/UCS-4, let's implement a simple decoder to use.
Utf8Scanner	Scanner for tokenizing XML content from a byte stream encoding using UTF-8 encoding, or something suitably close it for decoding purposes (including ISO-Latin1 and US-ASCII).
UTF8Writer
Utf8XmlWriter	This is the generic implementation of XmlWriter, used if the destination is byte-based OutputStream, and encoding is UTF-8.
ValidationException	Specific exception thrown when document has validation (DTD, W3C Schema) errors; things that are not well-formedness problems.
WFCException	Base class for reader-side Well-Formedness Constraint violation (fatal error) exceptions.
WName	This class is similar to PName, in that it implements an efficient representation of prefixed names, but one used on output (Writer) side.
WNameFactory	This abstract class defines factory object (with factory methods) that are needed by WNameTable instances, to be able to construct WName instances for element and attribute names.
WNameTable	This is a symbol table implementation used for storing byte-based WNames.
WriterConfig	This is the shared configuration object passed by the factory to writer.
XmlChars	Simple utility class that encapsulates logic of determining validity of characters outside basic 7-bit range of Unicode, for XML 1.0
XmlCharTypes	This is a simple container class, mostly used to encapsulate details of character typing out of parser/scanner/writer classes, while still making int arrays auto-generated only if needed (esp.
XmlConsts	Simple constant container interface, shared by input and output sides.
XmlNames	Simple utility class used for checking validity of xml names.
XmlScanner	This is the abstract base class for all scanner implementations, defining operations the actual parser requires from the low-level scanners.
XmlWriter	Base class for output type / encoding-specific serializers used to do actual physical output of serialized xml content.