All Classes

Class	Description
ArgUtil	Simple static utility class that contains (static) utility methods useful when parsing non-typesafe arguments (String-only configuration, command line args).
AsciiReader	Optimized Reader that reads ascii content from an input stream.
AsciiXmlWriter	Concrete implementation of EncodingXmlWriter used when output is to be encoded using 7-bit ascii (US-ASCII) encoding.
AttributeCollector	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.
BaseInputSource	Abstract base class that implements shared functionality that all current WstxInputSource implementations Woodstox includes need.
BaseNsContext	Abstract base class that defines extra features defined by most NamespaceContext implementations Wodstox uses.
BaseNsStreamWriter	Mid-level base class of namespace-aware stream writers.
BaseSchemaFactory	Shared base class extended by concrete schema factory implementations.
BaseStreamWriter	Base class for XMLStreamWriter implementations Woodstox has.
BasicStreamReader	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.
BijectiveNsMap	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.
BranchingReaderSource	Specialized input source that can "branch" input it reads; essentially both giving out read data AND also writing it out to a Writer.
BufferingXmlWriter	Concrete implementation of XmlWriter that will dispatch writes to another writer (of type Writer, and will NOT handle encoding.
BufferRecycler	This is a small utility class, whose main functionality is to allow simple reuse of raw byte/char buffers.
CharArraySource	Input source that reads input from a static char array, usually used when expanding internal entities.
CharsetNames	Simple utility class that normalizes given character input character set names into canonical (within Woodstox, anyways) names.
ChoiceContentSpec	Content specification that defines content model that has multiple alternative elements; including mixed content model.
ChoiceModel	Model class that encapsulates set of sub-models, of which one (and only one) needs to be matched.
CompactNsContext	Simple implementation of separate non-transient namespace context object.
CompactStartElement	Wstx StartElement implementation used when directly creating events from a stream reader.
CompletelyCloseable
ConcatModel	Model class that represents sequence of 2 sub-models, needed to be matched in the order.
ContentSpec	Abstract base class for classes that contain parts of a content specification of an element defined in DTD.
DataUtil
DefaultAttrValue	Simple container class used to contain information about the default value for an attribute.
DefaultEventAllocator	Straight-forward implementation of XMLEventAllocator, to be used with Woodstox' event reader.
DefaultInputResolver	Static utility class that implements the entity (external DTD subset, external parsed entities) resolution logics.
DefaultXmlSymbolTable	Factory class used for instantiating pre-populated XML symbol tables.
DFAState	Class that represents a state in DFA used for validating complex DTD content models.
DFAValidator	Validator class that is based on a DFA constructed from DTD content specification.
DOMOutputElement	Context object that holds information about an open element (one for which START_ELEMENT has been sent, but no END_ELEMENT)
DTDAttribute	Base class for objects that contain attribute definitions from DTD.
DTDCdataAttr	Simple DTDAttribute sub-class used for plain vanilla CDATA valued attributes.
DTDElement	Class that contains element definitions from DTD.
DTDEntitiesAttr	Specific attribute class for attributes that contain (unique) identifiers.
DTDEntityAttr	Specific attribute class for attributes that contain (unique) identifiers.
DTDEnumAttr	Specific attribute class for attributes that have enumerated values.
DTDEventListener
DTDId	Simple key object class, used for accessing (external) DTDs when stored for caching.
DTDIdAttr	Specific attribute class for attributes that contain (unique) identifiers.
DTDIdRefAttr	Attribute class for attributes that contain references to elements that have matching identifier specified.
DTDIdRefsAttr	Attribute class for attributes that contain multiple references to elements that have matching identifier specified.
DTDNmTokenAttr	Specific attribute class for attributes that contain (unique) identifiers.
DTDNmTokensAttr	Specific attribute class for attributes that contain (unique) identifiers.
DTDNotationAttr	Specific attribute class for attributes that are of NOTATION type, and also contain enumerated set of legal values.
DTDSchemaFactory	Factory for creating DTD validator schema objects (shareable stateless "blueprints" for creating actual validators).
DTDSubset	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.
DTDSubsetImpl	The default implementation of DTDSubset
DTDTypingNonValidator	This class is a "non-validating validator"; a validator-like object that handles DTD-based non-validation functionality: determining type information and default values.
DTDValidator	Woodstox implementation of XMLValidator; the class that handles DTD-based validation.
DTDValidatorBase	Shared abstract base class for Woodstox implementations of XMLValidator for DTD validation.
EBCDICCodec	This is a container class for EBCDIC code page(s) that we need to properly bootstrap EBCDIC encoded xml documents.
ElemAttrs	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.
ElemCallback	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.
ElementId	Simple container Object used to store information about id attribute values, and references to such (as of yet undefined) values.
ElementIdMap	This class is a specialized type-safe linked hash map used for storing ElementId instances.
EmptyElementHandler	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.
EmptyElementHandler.HtmlEmptyElementHandler	HTML specific empty element handler.
EmptyElementHandler.SetEmptyElementHandler	Handler that uses a Set of Strings.
EmptyNamespaceContext	Dummy NamespaceContext (and BaseNsContext) implementation that is usually used in non-namespace-aware mode.
EmptyValidator	Simple content model validator that accepts no elements, ever; this is true for pure #PCDATA content model as well as EMPTY content model.
EncodingXmlWriter	Intermediate base class used when outputting to streams that use an encoding that is compatible with 7-bit single-byte Ascii encoding.
EntityDecl	Abstract base class for various entity declarations DTD reader has parsed from DTD subsets.
ErrorConsts	"Static" class that contains error message constants.
ExceptionUtil
ExtEntity
FullDTDReader	Reader that reads in DTD information from internal or external subset.
GenericMsvValidator	Generic validator instance to be used for all Multi-Schema Validator backed implementations.
InputBootstrapper	Abstract base class that defines common API used with both stream and reader-based input sources.
InputConfigFlags	Constant interface that contains configuration flag used by parser and parser factory, as well as some other input constants.
InputElementStack	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.
InputFactoryProviderImpl
InputProblemReporter	Interface implemented by input reader, and used by other components to report problem that are related to current input position.
InputSourceFactory	Factory class that creates instances of WstxInputSource to allow reading input from various sources.
IntEntity
InternCache	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.
InvalidCharHandler	Simple converter interface designed to be used with stream writer property WstxOutputProperties.P_OUTPUT_INVALID_CHAR_HANDLER.
InvalidCharHandler.FailingHandler	This handler implementation just throws an exception for all invalid characters encountered.
InvalidCharHandler.ReplacingHandler	Alternative to the default handler, this handler converts all invalid characters to the specified output character.
ISOLatin1XmlWriter	Concrete implementation of EncodingXmlWriter used when output is to be encoded using ISO-8859-1, aka ISO-Latin1 encoding.
ISOLatinReader	Optimized Reader that reads ISO-Latin (aka ISO-8859-1) content from an input stream.
LargePrefixedNameSet	Implementation of PrefixedNameSet suitable for storing large number of entries; basically anything above trivially small sets (4 or less).
MergedNsContext	Hierarchic NamespaceContext implementation used when constructing event and namespace information explicitly via XMLEventFactory, not by a stream reader.
MergedReader	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.
MergedStream	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.
MinimalDTDReader	Minimal DTD reader implementation that only knows how to skip internal DTD subsets.
ModelNode	Abstract base class for classes constructed from ContentSpec objects, when they get rewritten (when their ContentSpec.rewrite() gets called).
NonNsStreamWriter	Implementation of XMLStreamWriter used when namespace support is not enabled.
NsDefaultProvider	Interface only used by Woodstox core.
OptionalModel	Content specification class that represents an optional specification.
OutputConfigFlags	Constant interface that contains configuration flag used by output classes internally, for presenting on/off configuration options.
OutputElementBase	Class that encapsulates information about a specific element in virtual output stack for namespace-aware writers.
OutputFactoryProviderImpl
ParsedExtEntity
ParsingErrorMsgs
PrefixedName	Simple key Object to be used for storing/accessing of potentially namespace scoped element and attribute names.
PrefixedNameSet
QNameCreator	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.
ReaderBootstrapper	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.
ReaderConfig	Simple configuration container class; passed by reader factory to reader instance created.
ReaderCreator	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).
ReaderSource	Input source that reads input via a Reader.
RelaxNGSchema	This is a validation schema instance based on a RELAX NG schema.
RelaxNGSchemaFactory	This is a StAX2 schema factory that can parse and create schema instances for creating validators that validate documents to check their validity against specific Relax NG specifications.
RepairingNsStreamWriter	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.
SAXFeature	Type safe (pre-Java5) enumeration for listing all currently (SAX 2.0.2) defined standard features
SAXProperty	Type-safe (pre-Java5) enumeration of all currently (SAX 2.0.2) defined standard properties.
SeqContentSpec	Content specification that defines model that has sequence of one or more elements that have to come in the specified order.
SimpleCache<K,V>	Simple Map implementation usable for caches where contents do not expire, but where size needs to remain bounded.
SimpleNsStreamWriter	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.
SimpleOutputElement	Class that encapsulates information about a specific element in virtual output stack for namespace-aware writers.
SimpleStartElement	Wstx StartElement implementation used when event is constructed from already objectified data, for example when constructed by the event factory.
SmallPrefixedNameSet	PrefixedNameSet implementation suitable for storing small set of PrefixedName values (generally 8 or less).
StarModel	Model class that represents any number of repetitions of its submodel (including no repetitions).
StreamBootstrapper	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).
StreamReaderImpl	Interface that defines "internal Woodstox API".
StreamScanner	Abstract base class that defines some basic functionality that all Woodstox reader classes (main XML reader, DTD reader) extend from.
StringUtil
StringVector	Data container similar List (from storage perspective), but that can be used in multiple ways.
StructValidator	Base class for validator Objects used to validate tree structure of an XML-document against DTD.
SymbolTable	This class is a kind of specialized type-safe Map, from char array to String value.
SystemId	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.
TextAccumulator	Simple utility class used to efficiently accumulate and concatenate text passed in various forms
TextBuffer	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.
TextBuilder	Class similar to StringBuilder, except that it can be used to construct multiple Strings, that will share same underlying character buffer.
TextEscaper
TokenContentSpec	Content specification that defines content model consisting of just one allowed element.
TokenModel	Model class that encapsulates a single (obligatory) token instance.
TypedStreamReader	Complete implementation of XMLStreamReader2, including Typed Access API (Stax2 v3.0) implementation.
TypedStreamWriter	Intermediate base class that implements Typed Access API (Stax2 v3) for all (repairing, non-repairing, non-namespace) native stream writer implementations.
UnparsedExtEntity
URLUtil
UTF32Reader	Since JDK does not come with UTF-32/UCS-4, let's implement a simple decoder to use.
UTF8Reader	Optimized Reader that reads UTF-8 encoded content from an input stream.
UTF8Writer	Specialized buffering UTF-8 writer used by XmlWriter.
ValidatingStreamReader	Implementation of XMLStreamReader2 that builds on TypedStreamReader and adds full DTD-handling including DTD validation
ValidationSchemaFactoryProviderImpl
ValidatorConfig
W3CMultiSchemaFactory	This is a StAX2 schema factory that can parse and create schema instances for creating validators that validate documents to check their validity against specific W3C Schema instances.
W3CSchema	This is a validation schema instance based on a W3C schema.
W3CSchemaFactory	This is a StAX2 schema factory that can parse and create schema instances for creating validators that validate documents to check their validity against specific W3C Schema instances.
WDTD	Event that contains all StAX accessible information read from internal and external DTD subsets.
WEntityDeclaration	Simple implementation of StAX entity declaration events; for the most just wraps a EntityDecl instance.
WEntityReference	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.
WNotationDeclaration	Woodstox implementation of NotationDeclaration2.
WordResolver	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.
WordSet	An efficient (both memory and time) implementation of a Set used to verify that a given word is contained within the set.
WrappedSaxException	Simple type-safe wrapper used for "tunneling" SAX exceptions through interfaces that do not allow them to be thrown.
WriterConfig	Simple configuration container class; passed by writer factory to writer instance created.
WstxBundleActivator	This class is responsible for registering OSGi service(s) that Woodstox package provides.
WstxDOMWrappingReader
WstxDOMWrappingWriter	This is an adapter class that allows building a DOM tree using XMLStreamWriter interface.
WstxEOFException	Exception thrown during parsing, if an unexpected EOF is encountered.
WstxEventFactory	Implementation of XMLEventFactory to be used with Woodstox.
WstxEventReader	Woodstox version of XMLEventReader2 (and XMLEventReader).
WstxException	Base class for all implementatations of XMLStreamException Wstx uses.
WstxInputData	Base class used by readers (specifically, by StreamScanner, and its sub-classes) to encapsulate input buffer portion of the class.
WstxInputFactory	Factory for creating various Stax objects (stream/event reader, writer).
WstxInputLocation	Basic implementation of Location, used by Wstx readers.
WstxInputProperties	Class that contains constant for property names used to configure cursor and event readers produced by Wstx implementation of XMLInputFactory.
WstxInputProperties.ParsingMode	Inner class used for creating type-safe enumerations (prior to JDK 1.5).
WstxInputSource	Interface that defines API actual parsers (stream readers) can use to read input from various input sources.
WstxIOException	Simple wrapper for IOExceptions; needed when StAX does not expose underlying I/O exceptions via its methods.
WstxLazyException	Alternative exception class Woodstox code uses when it is not allowed to throw an instance of XMLStreamException; this generally happens when doing lazy parsing.
WstxOutputException	Exception class used for notifying about well-formedness errors that writers would create.
WstxOutputFactory	Implementation of XMLOutputFactory for Wstx.
WstxOutputProperties	Class that contains constant for property names used to configure cursor and event writers produced by Woodstox implementation of XMLOutputFactory.
WstxParsingException	Intermediate base class for reporting actual Wstx parsing problems.
WstxSAXParser	This class implements parser part of JAXP and SAX interfaces; and effectively offers an alternative to using Stax input factory / stream reader combination.
WstxSAXParserFactory	This is implementation of the main JAXP SAX factory, and as such acts as the entry point from JAXP.
WstxUnexpectedCharException	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.
WstxValidationException	Specific exception thrown when document has validation (DTD, W3C Schema) errors; things that are not well-formedness problems.
XmlChars	Simple utility class that encapsulates logic of determining validity of characters outside basic 7-bit range of Unicode, for XML 1.0
XmlConsts	Simple constant container interface, shared by input and output sides.
XmlWriter	This is the base class for actual physical xml outputters.
XmlWriterWrapper	This is a simple wrapper class, which decorates an XmlWriter to look like a Writer.