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