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.
Concrete implementation of XmlWriter that will dispatch writes to another writer (of type Writer, and will NOT handle encoding.
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 DTDSubset
This 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
invalid reference
DTDReader
when writing out flattened external DTD subset file.
This 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.
 
Helper class used to solve [WSTX-174]: some older AppServers were shipped with incompatible version of QName class, which is missing the 3 argument constructor.
Helper class used to encapsulate calls to the missing method.
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 validation
 
 
 
Event 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.