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.