All Classes and Interfaces
Class
Description
This base class defines interface used for efficient encoding
of typed values, by stream writers.
Interface that is used to allow validators to do attribute defaulting.
Interface that specifies additional access methods for accessing
combined attribute information reader has, after parsing individual
and combining that with DTD information (if any available; depends on
parser's mode).
Abstract base class used to share functionality between concrete
base64 decoders.
This abstract base class is used to define specific details of which
variant of Base64 encoding/decoding is to be used.
This class is used as a container for commonly used Base64 variants.
This abstract base class implements common functionality for
Stax2 reference implementation's event API part.
Base64 decoder that can be used to decode base64 encoded content that
is passed as char arrays.
This is an adapter class that presents a DOM document as if it was
a regular
XMLStreamReader.This is an adapter class that partially implements
XMLStreamWriter
as a facade on top of a DOM document or Node, allowing one
to basically construct DOM trees via Stax API.Interface that extends basic
DTD with methods that are
necessary to completely reproduce actual DOCTYPE declaration
constructs in xml documents.Vanilla implementation of a DTD event.
Interface that specifies additional access functionality to parsed DTD
information (if any); these methods are encapsulated on a separate
interface to keep the main reader interface from exploding.
Specialized interface that covers schema features unique to DTDs.
Simple implementation of "null iterator", iterator that has nothing to
iterate over.
Dummy
NamespaceContext implementation that contains no
namespace information, except bindings that are specified by
the namespace specification itself (for prefixes "xml" and "xmlns")Simple base implementation that can be used either as a placeholder,
or a base for 'real' entity declaration implementations.
Interface that defines API for the factories stream writers use for
creating "escaping writers".
Interface that specifies additional access methods for accessing
full location information of an input location within a stream reader.
Helper class used to combine an enclosing namespace context with
a list of namespace declarations contained, to result in a single
namespace context object.
Implementation of
Namespace.Interface that extends basic
NotationDeclaration to add
support for handling Base URI needed to resolve Notation references.Helper class that contains method for converting numeric
values to and from String representations.
Helper class used for serializing typed values to String.
Simple read-only iterator that iterators over one specific item, passed
in as constructor argument.
Wstx
StartElement implementation used when event is constructed
from already objectified data, for example when constructed by the event
factory.This is the mid-level abstract base class for
Stax2Results
that an be used to write to in-memory (low-level) data structures,
such as byte and char arrays, StringBuffers and so forth.This is the mid-level abstract base class for
Stax2Sources
that an be used to access fixed-length in-memory data sources, such
as byte and char arrays, Strings, StringBuffers and so forth.Simple implementation of
Stax2BlockSource that encapsulates
a byte array.Simple implementation of
Stax2BlockSource that encapsulates
an char array.Base implementation of
XMLEventAllocator, to be
used either as is, or as a base for more specialized Stax2
event allocator implementation.This is an abstract almost complete plain vanilla implementation of
XMLEventFactory2.This adapter implements parts of
XMLEventReader2, the
extended stream reader defined by Stax2 extension, by wrapping
a vanilla Stax 1.0 XMLEventReader implementation.Almost complete implementation of
XMLEventReader2, built on top of
a generic XMLStreamReader implementation (using aggregation).Simple implementation of
XMLEventWriter.Simple implementation of
Stax2ReferentialResult, which refers
to the specific file.Simple implementation of
Stax2ReferentialSource, which refers
to the specific file.
Some notes about implemention:
There is no way to filter out values of peek(), so we'll just straight
dispatch the call to underlying reader
Simple straight-forward implementation of a filtering stream reader,
which can fully adapt Stax2 stream reader
(
XMLStreamReader2).Simple interface to be used for registering objects that
can construct
XMLInputFactory2 instances with OSGi framework.Simple implementation of
XMLStreamLocation2, which just
wraps Stax 1.0 Location and adds no-operation implementation
of the additions.Simple interface to be used for registering objects that
can construct
XMLOutputFactory2 instances with OSGi framework.This adapter implements parts of
XMLStreamReader2, the
extended stream reader defined by Stax2 extension, by wrapping
a vanilla Stax 1.0 XMLStreamReader implementation.This is a partial base implementation of
XMLStreamReader2,
the extended stream reader that is part of Stax2.This is the mid-level abstract base class for
Stax2Results
that refer to a resource in such a way, that an efficient
OutputStream or Writer can be constructed.This is the mid-level abstract base class for
Stax2Sources
that refer to a resource in such a way, that an efficient
InputStream or Reader can be constructed.This is the base class for additional output results (implementations
of
Result) that Stax2
XMLInputFactory2 implementations should support.This is the base class for additional input sources (implementations
of
Source) that Stax2
XMLInputFactory2 implementations should support.Simple implementation of
Stax2BlockSource that encapsulates
a simple String.Simple implementation of
Stax2ReferentialSource, which refers
to the specific file.Helper class for efficiently reading and aggregating variable length
byte content.
Helper class used to simplify text gathering while keeping
at as efficient as possible.
Simple interface to be used for registering objects that
can construct
XMLValidationSchemaFactory instances with OSGi framework.This adapter implements parts of
XMLStreamWriter2, the
extended stream writer defined by Stax2 extension, by wrapping
a vanilla Stax 1.0 XMLStreamReader implementation.This is a partial base implementation of
XMLStreamWriter2,
the extended stream writer that is part of Stax2.Similar to
StreamReaderDelegate,
but implements a proxy for XMLStreamWriter.Base64 decoder that can be used to decode base64 encoded content that
is passed as a Single string.
Base class that defines decoder used for decoding multiple
elements of an array type.
Base class that defines generic typed value decoder API used
by
TypedXMLStreamReader to allow for efficient customized
decoding of textual xml content into actual typed values.This class represents an exception throw by an
TypedXMLStreamReader or an TypedXMLStreamWriter.This interface provides a typed extension to
XMLStreamReader.This interface provides a typed extension to
XMLStreamWriter.Interface that defines API that Stax2 validation system exposes to the
applications.
Interface that defines functionality exposed by the "owner" of the
content to validate (usually a stream reader or stream writer) to
validators, needed in addition to actually validatable content, for
succesful validation.
This interface defines method(s) needed to implement a custom validation
problem (warning, error, fatal error) handler.
Simple utility class that allows chaining of
XMLValidator
instances.Factory class used to construct all
TypedValueDecoder
(and TypedArrayDecoder)
instances needed by a
single stream reader instance.Intermediate shared base class for token array decoders.
There are some things common to all textual decoders (like
white space trimming).
Factory class used to construct all
AsciiValueEncoder instances needed by a single
stream writer instance.Intermediate base class for encoders that deal with arrays
of values.
Concrete implementation used for encoding int[] content.
Intermediate base class for encoders that deal with single
primitive values.
Implementation of textual encoder that operates on longer
textual values.
Implementation of textual encoder that operates on short
textual values ("tokens").
Intermediate base class for typed (non-textual) scalar values
Interface that extends basic
XMLEvent2 with method(s)
that are missing from it; specifically linkage that allows using
a stream/event writer for outputting.Interface that adds missing (but required) methods to
XMLEventFactory; especially ones for creating actual
well-behaving DOCTYPE events.Extended interface that implements functionality that is missing
from
XMLEventReader, based on findings on trying to
implement Stax API v1.0.Extension of
XMLInputFactory that adds some convenience factory
methods as new standard properties that conforming stream
reader factory and instance implementations need to
recognize, and preferably support.Extension of
XMLInputFactory to add
missing functionality.Extension of
XMLReporter to allow for better access to
information about the actual problem.Extension of
Location that adds accessor to retrieve nested
location information.This interface defines configuration properties shared by multiple
kinds of factories (input, output, validation) or instances produces
(readers, writers, validators).
Extended interface that implements functionality that is necessary
to properly build event API on top of
XMLStreamReader.Extended interface that implements functionality that is necessary
to properly build event API on top of
XMLStreamWriter,
as well as to configure individual instances.Specialized sub-class of
XMLStreamException, to be used for
indicating fatal validation problems (when in mode in which exceptions
are to be thrown).Simple container class used to store a non-fatal problem
either to be returned as is, or to use for creating and throwing
a validation exception.
Defines the API that validator schema instances have to implement.
Defines an abstract factory for constructing
XMLValidationSchema
instances.Class that defines interface that individual (possibly) stateful validator
instances have to implement, and that both
XMLStreamReader and
XMLStreamWriter instances can call to validate
xml documents.