All Classes and Interfaces
Class
Description
Simple static utility class that contains (static) utility methods useful
when parsing non-typesafe arguments (String-only configuration, command
line args).
Optimized Reader that reads ascii content from an input stream.
Concrete implementation of
EncodingXmlWriter used when output
is to be encoded using 7-bit ascii (US-ASCII) encoding.Container for information collected regarding a single element
attribute instance.
Shared base class that defines API stream reader uses to communicate
with the attribute collector implementation, independent of whether it's
operating in namespace-aware or non-namespace modes.
Abstract base class that implements shared functionality that all current
WstxInputSource implementations Woodstox includes need.Abstract base class that defines extra features defined by most
NamespaceContext implementations Wodstox uses.
Mid-level base class of namespace-aware stream writers.
Simple basic class for optimized Readers Woodstox has; implements
"cookie-cutter" methods that are used by all actual implementations.
Shared base class of
StartElement implementations Wstx uses.Base class for
XMLStreamWriter implementations Woodstox has.Partial implementation of
XMLStreamReader2 consisting of
all functionality other than DTD-validation-specific parts, and
Typed Access API (Stax2 v3.0), which are implemented at
sub-classes.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.
Specialized input source that can "branch" input it reads; essentially
both giving out read data AND also writing it out to a Writer.
This is a small utility class, whose main functionality is to allow
simple reuse of raw byte/char buffers.
Input source that reads input from a static char array, usually used
when expanding internal entities.
Simple utility class that normalizes given character input character
set names into canonical (within Woodstox, anyways) names.
Content specification that defines content model that has
multiple alternative elements; including mixed content model.
Model class that encapsulates set of sub-models, of which one (and only
one) needs to be matched.
Shared common base class for variour configuration container implementations
for public factories Woodstox uses: implementations of
XMLInputFactory,
XMLOutputFactory and
XMLValidationSchemaFactory.Simple implementation of separate non-transient namespace context
object.
Wstx
StartElement implementation used when directly creating
events from a stream reader.Model class that represents sequence of 2 sub-models, needed to be
matched in the order.
Abstract base class for classes that contain parts of a content
specification of an element defined in DTD.
Simple container class used to contain information about the default
value for an attribute.
Straight-forward implementation of
XMLEventAllocator, to be
used with Woodstox' event reader.Static utility class that implements the entity (external DTD subset,
external parsed entities) resolution logics.
Factory class used for instantiating pre-populated XML symbol
tables.
Class that represents a state in DFA used for validating complex
DTD content models.
Validator class that is based on a DFA constructed from DTD content
specification.
Context object that holds information about an open element
(one for which START_ELEMENT has been sent, but no END_ELEMENT)
Base class for objects that contain attribute definitions from DTD.
Simple
DTDAttribute sub-class used for plain vanilla CDATA
valued attributes.Class that contains element definitions from DTD.
Specific attribute class for attributes that contain (unique)
identifiers.
Specific attribute class for attributes that contain (unique)
identifiers.
Specific attribute class for attributes that have enumerated values.
Simple key object class, used for accessing (external) DTDs when stored for
caching.
Specific attribute class for attributes that contain (unique)
identifiers.
Attribute class for attributes that contain references
to elements that have matching identifier specified.
Attribute class for attributes that contain multiple references
to elements that have matching identifier specified.
Specific attribute class for attributes that contain (unique)
identifiers.
Specific attribute class for attributes that contain (unique)
identifiers.
Specific attribute class for attributes that are of NOTATION type,
and also contain enumerated set of legal values.
Factory for creating DTD validator schema objects (shareable stateless
"blueprints" for creating actual validators).
This is the abstract base class that implements the standard Stax2
validation schema base class (
XMLValidationSchema, as well
as specifies extended Woodstox-specific interface for accessing
DTD-specific things like entity expansions and notation properties.The default implementation of
DTDSubsetThis class is a "non-validating validator"; a validator-like object
that handles DTD-based non-validation functionality: determining type
information and default values.
Woodstox implementation of
XMLValidator; the class that
handles DTD-based validation.Shared abstract base class for Woodstox implementations
of
XMLValidator for DTD validation.Simple utility class used by
when writing out
flattened external DTD subset file.
invalid reference
DTDReaderThis is a container class for EBCDIC code page(s) that we need
to properly bootstrap EBCDIC encoded xml documents.
Container class that is constructed with enough raw attribute information,
to be able to lazily construct full attribute objects, to be accessed
via Iterator, or fully-qualified name.
Abstract base class that defines set of simple callbacks to be
called by the stream reader, passing information about element
that the stream currently points to, if any.
Container for information collected regarding a single
(start) element instance.
Simple container Object used to store information about id attribute
values, and references to such (as of yet undefined) values.
This class is a specialized type-safe linked hash map used for
storing
ElementId instances.Optional handler used to determine if a specific empty element (by name) should
be allowed to use the self-closing syntax instead of having a separate end tag.
HTML specific empty element handler.
Handler that uses a Set of Strings.
Dummy
NamespaceContext (and BaseNsContext)
implementation that is usually used in
non-namespace-aware mode.Simple content model validator that accepts no elements, ever; this
is true for pure #PCDATA content model as well as EMPTY content model.
Intermediate base class used when outputting to streams that use
an encoding that is compatible with 7-bit single-byte Ascii encoding.
Abstract base class for various entity declarations DTD reader
has parsed from DTD subsets.
"Static" class that contains error message constants.
Reader that reads in DTD information from internal or external subset.
Abstract base class that defines common API used with both stream and
reader-based input sources.
Constant interface that contains configuration flag used by parser
and parser factory, as well as some other input constants.
Shared base class that defines API stream reader uses to communicate
with the element stack implementation, independent of whether it's
operating in namespace-aware or non-namespace modes.
Interface implemented by input reader, and used by other components to
report problem that are related to current input position.
Factory class that creates instances of
WstxInputSource to allow
reading input from various sources.Singleton class that implements "fast intern" functionality, essentially
adding a layer that caches Strings that have been previously intern()ed,
but that probably shouldn't be added to symbol tables.
Simple converter interface designed to be used with stream writer property
WstxOutputProperties.P_OUTPUT_INVALID_CHAR_HANDLER.This handler implementation just throws an exception for
all invalid characters encountered.
Alternative to the default handler, this handler converts all invalid
characters to the specified output character.
Concrete implementation of
EncodingXmlWriter used when output
is to be encoded using ISO-8859-1, aka ISO-Latin1 encoding.Optimized Reader that reads ISO-Latin (aka ISO-8859-1) content from an
input stream.
Implementation of
PrefixedNameSet suitable for storing large number
of entries; basically anything above trivially small sets (4 or less).Hierarchic
NamespaceContext implementation used when constructing
event and namespace information explicitly via
XMLEventFactory,
not by a stream reader.Simple
Reader implementation that is used to "unwind" some
data previously read from a Reader; 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 Reader.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.Minimal DTD reader implementation that only knows how to skip
internal DTD subsets.
Abstract base class for classes constructed from
ContentSpec
objects, when they get rewritten (when their ContentSpec.rewrite()
gets called).Implementation of
XMLStreamWriter used when namespace support
is not enabled.Interface only used by Woodstox core.
Content specification class that represents an optional specification.
Constant interface that contains configuration flag used by output
classes internally, for presenting on/off configuration options.
Class that encapsulates information about a specific element in virtual
output stack for namespace-aware writers.
Simple key Object to be used for storing/accessing of potentially namespace
scoped element and attribute names.
Input bootstrap class used when input comes from a Reader; in this case,
encoding is already known, and thus encoding from XML declaration (if
any) is only double-checked, not really used.
Simple configuration container class; passed by reader factory to reader
instance created.
Interface that defines callbacks readers can use to access settings
of the input factory that created them, as well as update cached
data factory may store (shared symbol tables, cached DTDs etc).
Input source that reads input via a Reader.
Namespace-aware implementation of
XMLStreamWriter, that does
namespace repairing, ie resolves possible conflicts between prefixes
(add new bindings as necessary), as well as automatically creates
namespace declarations as necessary.Type safe (pre-Java5) enumeration for listing all currently (SAX 2.0.2)
defined standard features
Type-safe (pre-Java5) enumeration of all currently (SAX 2.0.2) defined
standard properties.
Content specification that defines model that has sequence of one or more
elements that have to come in the specified order.
Simple validator that can be used if all components of a sequence
are leaf nodes, ie.
Simple Map implementation usable for caches where contents do not
expire, but where size needs to remain bounded.
Namespace-aware implementation of
XMLStreamWriter, that does
not do namespace repairing, ie doesn't try to resolve possible
conflicts between prefixes and namespace URIs, or automatically
create namespace bindings.Class that encapsulates information about a specific element in virtual
output stack for namespace-aware writers.
Simple key class used to represent two-piece (attribute) names;
first part being optional (URI), and second non-optional (local name).
Wstx
StartElement implementation used when event is constructed
from already objectified data, for example when constructed by the event
factory.PrefixedNameSet implementation suitable for storing small set of PrefixedName
values (generally 8 or less).
Model class that represents any number of repetitions of its submodel
(including no repetitions).
Input bootstrap class used with streams, when encoding is not known
(when encoding is specified by application, a reader is constructed,
and then reader-based bootstrapper is used).
Interface that defines "internal Woodstox API".
Abstract base class that defines some basic functionality that all
Woodstox reader classes (main XML reader, DTD reader) extend from.
Data container similar
List (from storage perspective),
but that can be used in multiple ways.Base class for validator Objects used to validate tree structure of an
XML-document against DTD.
This class is a kind of specialized type-safe Map, from char array to
String value.
This class is a symbol table entry.
Helper class that is used to defer construction of
URL
to help with cases where real URL is not actually needed, and
incoming System Id may not even resolve properly.Simple utility class used to efficiently accumulate and concatenate
text passed in various forms
TextBuffer is a class similar to
StringBuilder, with
following differences:
TextBuffer uses segments character arrays, to avoid having
to do additional array copies when array is not big enough.Class similar to
StringBuilder, except that it can be used to
construct multiple Strings, that will share same underlying character
buffer.Content specification that defines content model consisting of just
one allowed element.
Model class that encapsulates a single (obligatory) token instance.
Complete implementation of
XMLStreamReader2,
including Typed Access API (Stax2 v3.0) implementation.Intermediate base class that implements Typed Access API (Stax2 v3)
for all (repairing, non-repairing, non-namespace) native stream
writer implementations.
Since JDK does not come with UTF-32/UCS-4, let's implement a simple
decoder to use.
Optimized Reader that reads UTF-8 encoded content from an input stream.
Specialized buffering UTF-8 writer used by
XmlWriter.Implementation of
XMLStreamReader2
that builds on TypedStreamReader and adds full DTD-handling
including DTD validationEvent that contains all StAX accessible information read from internal
and external DTD subsets.
Simple implementation of StAX entity declaration events; for the
most just wraps a
EntityDecl instance.We need a slightly specialized version to support concept of
undeclared entities, which can be used in (non-default, non-standard)
mode where undeclared entities are allowed to be handled.
Woodstox implementation of
NotationDeclaration2.A specialized Map/Symbol table - like data structure that can be used
for both checking whether a word (passed in as a char array) exists
in certain set of words AND getting that word as a String.
An efficient (both memory and time) implementation of a Set used to
verify that a given
word is contained within the set.
Simple type-safe wrapper used for "tunneling" SAX exceptions
through interfaces that do not allow them to be thrown.
Simple configuration container class; passed by writer factory to writer
instance created.
This class is responsible for registering OSGi service(s) that Woodstox
package provides.
This is an adapter class that allows building a DOM tree using
XMLStreamWriter interface.Exception thrown during parsing, if an unexpected EOF is encountered.
Implementation of
XMLEventFactory to be used with
Woodstox.Woodstox version of
XMLEventReader2 (and XMLEventReader).Base class for all implementatations of
XMLStreamException
Wstx uses.Base class used by readers (specifically, by
StreamScanner, and its sub-classes)
to encapsulate input buffer portion of the class.Factory for creating various Stax objects (stream/event reader,
writer).
Basic implementation of
Location, used by Wstx readers.Class that contains constant for property names used to configure
cursor and event readers produced by Wstx implementation of
XMLInputFactory.Inner class used for creating type-safe enumerations (prior to JDK 1.5).
Interface that defines API actual parsers (stream readers)
can use to read input from various input sources.
Simple wrapper for
IOExceptions; needed when StAX does not expose
underlying I/O exceptions via its methods.Alternative exception class Woodstox code uses when it is not allowed
to throw an instance of
XMLStreamException; this generally
happens when doing lazy parsing.Exception class used for notifying about well-formedness errors that
writers would create.
Implementation of
XMLOutputFactory for Wstx.Class that contains constant for property names used to configure
cursor and event writers produced by Woodstox implementation of
XMLOutputFactory.Intermediate base class for reporting actual Wstx parsing problems.
This class implements parser part of JAXP and SAX interfaces; and
effectively offers an alternative to using Stax input factory /
stream reader combination.
This is implementation of the main JAXP SAX factory, and as such
acts as the entry point from JAXP.
Generic exception type that indicates that tokenizer/parser encountered
unexpected (but not necessarily invalid per se) character; character that
is not legal in current context.
Specific exception thrown when document has validation (DTD, W3C Schema)
errors; things that are not well-formedness problems.
Simple utility class that encapsulates logic of determining validity
of characters outside basic 7-bit range of Unicode, for XML 1.0
Simple constant container interface, shared by input and output
sides.
This is the base class for actual physical xml outputters.
This is a simple wrapper class, which decorates an
XmlWriter
to look like a Writer.This wrapper directs calls to
writeRaw methods.This wrapper directs calls to
writeCharacters methods.