All Classes and Interfaces

Class
Description
Class that contains constant for property names used to configure cursor and event readers produced by Aalto implementation of XMLInputFactory.
This is the generic implementation of XmlWriter, used if the destination is byte-based OutputStream, and encoding is 7-bit (US) Ascii.
 
This is the base class for asynchronous (non-blocking) XML scanners.
 
This is the base class for asynchronous (non-blocking) XML scanners.
 
Interface used by AsyncXMLStreamReader to get more input to parse.
Implementation of AsyncXMLStreamReader.
Helper class that contains specialized decode methods for pseudo-attributes contained in XML declaration.
Extension of XMLInputFactory2 to provide factory methods for constructing non-blocking (asynchronous) parsers (of type AsyncXMLStreamReader.
Extension of XMLStreamReader2 used by non-blocking ("async") stream readers.
Object used by the tokenizer to collect and store information about attributes, specifically, names and values.
 
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.
This is a small utility class, whose main functionality is to allow simple reuse of raw byte/char buffers.
This intermediate abstract class defines more specialized API needed by components like symbol tables, which need to provide efficient access to byte-based PNames.
Simple factory that can instantiate appropriate PName instances, given input data to use for construction.
This is a symbol table implementation used for storing byte-based PNames, specifically, instances of (ByteBasedPName).
 
Intermediate base class used by different byte-backed scanners.
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.
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).
This abstract base class (partial implementation of XmlWriter) is used if the destination is byte-based OutputStream.
This is a symbol table implementation used for storing byte-based PNames, specifically, instances of (PNameC).
This class is a symbol table entry.
Simple utility class that normalizes given character input character set names into canonical (within context of this processor) names
Class that takes care of bootstrapping main document input from a Stream input source.
This class is similar to PName, in that it implements an efficient representation of prefixed names, but one used on output (Writer) side.
This is the generic implementation of XmlWriter, used if the destination is a character based, like a Writer.
Base class for reader and writer-side configuration/context objects
 
Context object that holds information about an open element (one for which START_ELEMENT has been sent, but no END_ELEMENT)
Concrete DOM-backed implementation, based on the Stax2 reference implementation's default implementation.
This is an adapter class that allows building a DOM tree using XMLStreamWriter interface.
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)
Simple implementation of "null iterator", iterator that has nothing to iterate over.
 
This class contains various String constants used for error reporting.
Specialized event allocator implementation.
Simple event factory implementation, mostly based on the reference implementation included in Stax2 API jar.
Simple implementation based on Stax2 reference implementation base.
Non-transient implementation of NamespaceContext.
 
 
Bogus XMLEvent returned when the next event is not yet available, in case of non-blocking (async) parsing.
Abstract base class that defines shared functionality between different bootstrappers (byte stream, char Readers, block input)
 
Aalto implementation of basic Stax factory (both XMLInputFactory and XMLInputFactory2) as well as API for producing non-blocking (async) parsers (that is, AsyncXMLInputFactory).
Simple wrapper for IOExceptions; needed when StAX does not expose underlying I/O exceptions via its methods.
This is the generic implementation of XmlWriter, used if the destination is byte-based OutputStream, and encoding is ISO-8859-1 (aka Latin1)
Basic implementation of XMLStreamLocation2, used by stream readers and writers.
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.
This class defines the basic high-level interface for symbol table implementations, especially regarding how they are obtained and reused.
Concrete implementation of StreamWriterBase, which implements basic namespace-aware, non repairing functionality.
Simple helper class to allow resolving of namespace bindings either from prefix to URI, or vice versa.
This is a simple container class to use for encapsulating dynamic (current) binding from a prefix, to a namespace URI (or missing binding by URI being null).
This class encapsulates information about a namespace binding declaration, associated with start elements.
 
Simple container for information regarding an open element within stream writer output.
 
Class that encapsulates information about a specific element in virtual output stack for namespace-aware writers.
Basic implementation of XMLOutputFactory.
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.
Specialized implementation of PName: can be used for short Strings that consists of at most 4 bytes.
Specialized implementation of PName: can be used for short Strings that consists of at most 8 bytes.
Specialized implementation of PName: can be used for medium-sized Strings that consists of at most 9-12 bytes.
An alternate implementation of PName: instead of coming straight from byte contents, it is actually just built from a character array.
General implementation of PName to be used with longer names (ones that consist of more than 8 bytes).
This is the shared configuration object passed by the factory to reader, and by reader to whoever needs it (scanners at least).
This is a simple container class that is used to encapsulate per-factory encoding-dependant information like symbol tables.
This is the concrete scanner implementation used when input comes as a Reader.
Concrete implementation of StreamWriterBase, which implements the "namespace repairing" mode of operation.
Simple non-automated manual test code for outputting namespace-aware XML documents.
Enumeration for listing all currently (SAX 2.0.2) defined standard features
This is implementation of the main JAXP SAX factory, and as such acts as the entry point from JAXP.
 
 
 
Enumeration for listing all currently (SAX 2.0.2) defined standard properties.
Container for utility methods needed by the parser factory, or parser wrapper components.
This is the common base class for writers that output to byte-backed output sources, and use Ascii or ISO-8859-1 (Latin1) encoding.
Simple read-only iterator that iterators over one specific item, passed in as constructor argument.
Base class for all XMLStreamException instances that we use.
Basic backend-independent XMLStreamReader implementation.
Base class for various byte stream based scanners (generally one for each type of encoding supported).
Base class for XMLStreamReader implementations.
 
Simple helper test class for checking how stream reader handles xml documents.
Simple helper test class for checking how stream reader handles xml documents.
 
 
 
 
 
 
 
Simple helper test class for checking how the parser works when used via SAX interface.
 
 
Simple test driver for testing pass-through copying using new StAX2 methods.
Simple helper test class for checking how stream reader handles xml documents.
Simple typed information access stress test, useful for profiling, as well as for quickly checking high-level performance effects of changes (albeit not very accurately, obviously -- need longer running composite tests for such verifications).
 
Simple utility class used to efficiently accumulate and concatenate text passed in various forms
Class conceptually similar to StringBuilder, but that allows for bit more efficient building, using segmented internal buffers, and direct access to these buffers.
 
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.
This class is used for canonicalization of namespace URIs.
We'll use a bounded map, which should work well for most normal cases, but avoid excesses for degenerate cases (unique URIs used as idenfitiers etc).
 
 
Since JDK does not come with UTF-32/UCS-4, let's implement a simple decoder to use.
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).
 
This is the generic implementation of XmlWriter, used if the destination is byte-based OutputStream, and encoding is UTF-8.
Specific exception thrown when document has validation (DTD, W3C Schema) errors; things that are not well-formedness problems.
Base class for reader-side Well-Formedness Constraint violation (fatal error) exceptions.
This class is similar to PName, in that it implements an efficient representation of prefixed names, but one used on output (Writer) side.
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.
This is a symbol table implementation used for storing byte-based WNames.
 
This is the shared configuration object passed by the factory to writer.
This is a simple container class that is used to encapsulate per-factory encoding-dependant information like symbol tables.
Simple utility class that encapsulates logic of determining validity of characters outside basic 7-bit range of Unicode, for XML 1.0
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.
Simple constant container interface, shared by input and output sides.
Simple utility class used for checking validity of xml names.
This is the abstract base class for all scanner implementations, defining operations the actual parser requires from the low-level scanners.
Base class for output type / encoding-specific serializers used to do actual physical output of serialized xml content.