All Classes and Interfaces

Class
Description
This is the base class of all date/time datatype validators.
This is the base class of all DOM parsers.
This is the base class of all SAX parsers.
 
 
This is the base class for all XML document parsers.
Represent the schema type "anySimpleType"
Represent the schema type "anyURI"
A simple ASCII byte reader.
Deprecated. 
Deprecated. 
AttributeMap inherits from NamedNodeMapImpl and extends it to deal with the specifics of storing attributes.
Attribute PSV infoset augmentations implementation.
Wraps XMLAttributes and makes it look like AttributeList and Attributes2.
Attribute represents an XML-style attribute of an Element.
This class represents a single attribute.
AttrNSImpl inherits from AttrImpl and adds namespace support.
This class provides an implementation for Augmentations interface.
This class provides encode/decode for RFC 2045 Base64 as defined by RFC 2045, N.
Represent the schema type "base64Binary"
the factory to create/return built-in schema DVs and create user-defined DVs
the base factory to create/return built-in schema DVs and create user-defined DVs
A very basic parser configuration.
Boyer-Moore searcher.
Represent the schema type "boolean"
Implementation of org.apache.xerces.xs.datatypes.ByteList.
A parser pool that enables caching of grammars.
Shadowed grammar pool.
Synchronized grammar pool.
XML provides the CDATA markup to allow a region of text in which most of the XML delimiter recognition does not take place.
CharacterData is an abstract Node that can carry character data as its Value.
ChildNode inherits from NodeImpl and adds the capability of being a child by having references to its previous and next siblings.
Content model any node.
Content model Bin-Op node.
This class constructs content models for a given grammar.
Content model leaf node.
A content model node.
This class is a very simple bitset class.
Content model Uni-Op node.
Represents an XML (or HTML) comment.
An extension of ValidationState which can be configured to turn off checking for ID/IDREF errors and unparsed entity errors.
Commonly used constants.
The Document interface represents the entire HTML or XML document.
The DOMImplementation class is description of a particular implementation of the Document Object Model.
Base class for datatype exceptions.
Factory that creates new javax.xml.datatype Objects that map XML to/from Java Objects.
Used to format JAXP 1.3 Datatype API error messages using a specified locale.
The interface that a DTD datatype must implement.
Validator for datatype (W3C Schema datatypes)
Validator for <dateTime> datatype (W3C Schema Datatypes)
Validator for <gDay> datatype (W3C Schema datatypes)
Represent the schema type "decimal"
This class implements the DOM's NodeList behavior for Element.getElementsByTagName()
Default error handler.
A NamespaceContext which only contains bindings for the xml and xmlns prefixes.
The Text interface inherits from CharacterData and represents the textual content (termed character data in XML) of an Element or Attr.
Attribute represents an XML-style attribute of an Element.
DeferredAttrNSImpl is to AttrNSImpl, what DeferredAttrImpl is to AttrImpl.
XML provides the CDATA markup to allow a region of text in which most of the XML delimiter recognition does not take place.
Represents an XML (or HTML) comment.
The Document interface represents the entire HTML or XML document.
This class represents a Document Type declaraction in the document itself, not a Document Type Definition (DTD).
This DOMImplementation class is description of a particular implementation of the Document Object Model.
NON-DOM CLASS: Describe one of the Elements (and its associated Attributes) defined in this Document Type.
Elements represent most of the "markup" and structure of the document.
DeferredElementNSImpl is to ElementNSImpl, what DeferredElementImpl is to ElementImpl.
Entity nodes hold the reference data for an XML Entity -- either parsed or unparsed.
EntityReference models the XML &entityname; syntax, when used for entities defined by the DOM.
An interface for deferred node object.
Notations are how the Document Type Description (DTD) records hints about the format of an XML "unparsed entity" -- in other words, non-XML data bound to this document type, which some applications may wish to consult when manipulating the document.
Processing Instructions (PIs) permit documents to carry processor-specific information alongside their actual content.
Text nodes hold the non-markup, non-Entity content of an Element or Attribute.
DFAContentModel is the derivative of ContentModel that does all of the non-trivial element content validation.
 
 
DocumentFragment is a "lightweight" or "minimal" Document object.
The Document interface represents the entire HTML or XML document.
This class represents a Document Type declaraction in the document itself, not a Document Type Definition (DTD).
Deprecated. 
Xerces implementation of DOMConfiguration that maintains a table of recognized parameters.
This class wraps DOM entity resolver to XNI entity resolver.
This class handles DOM errors .
DOMErrorImpl is an implementation that describes an error.
The DOMImplementation class is description of a particular implementation of the Document Object Model.
This class implements the DOM Level 3 Core interface DOMImplementationList.
Supply one the right implementation, based upon requested features.
This Class DOMInputImpl represents a single input source for an XML entity.
An XMLInputSource analogue to javax.xml.transform.dom.DOMSource.
DOMLocatorImpl is an implementaion that describes a location (e.g.
Used to format DOM error messages, using the system locale.
This class adds implementation for normalizeDocument method.
This class represents an output destination for data.
This is the main Xerces DOM parser class.
This is Xerces DOM Builder class.
DOM Level 3 This class implements the DOM Level 3 Core interface DOMStringList.
Some useful utility methods.
Allows to retrieve XSImplementation, DOM Level 3 Core and LS implementations and PSVI implementation.
Represent the schema type "double"
This is the DTD-only parser configuration.
The factory to create and return DTD types.
the factory to create/return built-in schema DVs and create user-defined DVs
A DTD grammar.
A simple Hashtable implementation that takes a tuple (String, String) as the key and a int as value.
This very simple class is the skeleton of what the DTDValidator could use to store various grammars that it gets from the GrammarPool.
 
Validator for <duration> datatype (W3C Schema Datatypes)
A runtime exception that's thrown if an error happens when the application tries to get a DV factory instance.
NON-DOM CLASS: Describe one of the Elements (and its associated Attributes) defined in this Document Type.
Elements represent most of the "markup" and structure of the document.
ElementNSImpl inherits from ElementImpl and adds namespace support.
Element PSV infoset augmentations implementation.
Location which always returns -1 and null from its methods.
EncodingMap is a convenience class which handles conversions between IANA encoding names and Java encoding names, and vice versa.
ENTITYDatatypeValidator implements the DatattypeValidator interface.
Represent the schema type "entity"
Entity nodes hold the reference data for an XML Entity -- either parsed or unparsed.
EntityReference models the XML &entityname; syntax, when used for entities defined by the DOM.
This class wraps a SAX entity resolver (EntityResolver2) in an XNI entity resolver.
This class wraps a SAX entity resolver in an XNI entity resolver.
The entity state interface defines methods that must be implemented by components that store information about entity declarations, as well as by entity validator that will need to validate attributes of type entity.
Wraps XMLErrorHandler and make it look like a SAX ErrorHandler.
This class wraps a SAX error handler in an XNI error handler.
EventImpl is an implementation of the basic "generic" DOM Level 2 Event object.
A special factory to create/return built-in schema DVs and create user-defined DVs that includes anyAtomicType, yearMonthDuration and dayTimeDuration
This interface extends XMLEntityResolver providing a method to resolve external subsets for documents which do not explicitly provide one.
Schema identity constraint field.
Field XPath.
Interface for a field activator.
Represent the schema type "float"
the factory to create/return built-in schema DVs and create user-defined DVs
format validation This class encodes/decodes hexadecimal data
Represent the schema type "hexBinary"
This class represents an input source for an XML resource retrievable over HTTP.
IDDatatypeValidator - ID represents the ID attribute type from XML 1.0 Recommendation.
Represent the schema type "ID"
Base class of Schema identity constraint.
IDREFDatatypeValidator - represents the IDREFS attribute type from XML 1.0 recommendation.
Represent the schema type "IDREF"
An immutable StAX Location.
Represent the schema type "integer"
This is configuration uses a scanner that integrates both scanning of the document and binding namespaces.
A simple integer based stack.
Datatype exception for invalid facet.
Datatype exception for invalid values.
This interface holds JAXP constant property/attribute names and values.
A read-only XNI wrapper around a JAXP NamespaceContext.
Schema key reference identity constraint.
Reader for the ISO-8859-1 encoding.
For list types: ENTITIES, IDREFS, NMTOKENS.
Represent the schema list types
Wraps XMLLocator and make it look like a SAX Locator.
Contains a list of LSInputs.
Signals that a malformed byte sequence was detected by a java.io.Reader that decodes bytes of a given encoding into characters.
An instance of this class has ranges captured in matching.
This interface provides a generic message formatting mechanism and is useful for producing messages that must be localized and/or formatted with replacement text.
MixedContentModel is a derivative of the abstract content model base class that handles the special case of mixed model elements.
Validator for <gMonthDay> datatype (W3C Schema Datatypes)
Validator for <gMonth> datatype (W3C Schema Datatypes)
An implementation of the DOM Level 2 MouseEvent interface.
This implementation of NamespaceContext has the ability to maintain multiple scopes of namespace/prefix bindings.
An implementation of the DOM Level 2 MutationEvent interface.
NamedNodeMaps represent collections of Nodes that can be accessed by name.
Namespace support for XML document handlers.
NMTOKEN datatype validator.
NodeImpl provides the basic structure of a DOM tree.
DefaultNodeIterator implements a NodeIterator, which iterates a DOM tree in the expected depth first way.
This is the non validating parser configuration.
NOTATIONValidator defines the interface that data type validators must obey.
Notations are how the Document Type Description (DTD) records hints about the format of an XML "unparsed entity" -- in other words, non-XML data bound to this document type, which some applications may wish to consult when manipulating the document.
Contains a list of Objects.
ParentNode inherits from ChildNode and adds the capability of having child nodes.
This class implements the basic operations for managing parser configuration features and properties.
Processing Instructions (PIs) permit documents to carry processor-specific information alongside their actual content.
Attribute namespace implementation; stores PSVI attribute items.
Our own document implementation, which knows how to create an element with PSVI information.
The DOMImplementation class is description of a particular implementation of the Document Object Model.
Element namespace implementation; stores PSVI element items.
Represent the schema type "QName" and "NOTATION"
The RangeImpl class implements the org.w3c.dom.range.Range interface.
A regular expression matching engine using Non-deterministic Finite Automaton (NFA).
DOM Revalidation handler adds additional functionality to XMLDocumentHandler
An XMLInputSource analogue to javax.xml.transform.sax.SAXSource.
A light wrapper around a SAX locator.
Used to format SAX error messages using a specified locale.
This is the main Xerces SAX parser class.
This is the implementation specific class for the javax.xml.parsers.SAXParserFactory.
This is the implementation specific class for the javax.xml.parsers.SAXParser.
Extension of SAXParser.
Defines a factory API that enables applications to
the factory to create/return built-in schema 1.0 DVs and create user-defined DVs
This class is to hold all schema component declaration that are declared within one namespace.
 
A partial schema for schemas for validating annotations.
This class customizes the behaviour of the util.NamespaceSupport class in order to easily implement some features that we need for efficient schema handling.
Collection of symbols used to parse a Schema Grammar.
This configuration enhances Xerces support for the JAXP secure processing feature.
This configuration allows Xerces to behave in a security-conscious manner; that is, it permits applications to instruct Xerces to limit certain operations that could be exploited by malicious document authors to cause a denail-of-service attack when the document is parsed.
This class is a container for parser settings that relate to security, or more specifically, it is intended to be used to prevent denial-of-service attacks from being launched against a system running Xerces.
Schema identity constraint selector.
Schema identity constraint selector XPath expression.
Shadowed symbol table.
Contains a list of shorts.
SimpleContentModel is a derivative of the abstract content model base class that handles a small set of simple content models that are just way overkill to give the DFA treatment.
An XMLLocator implementation used for schema error reporting.
This symbol table uses SoftReferences to its String entries, which means that table entries that have no references to them can be garbage collected when memory is needed.
This class is a symbol table entry.
 
This parser configuration extends the default configuration allowing Xerces to handle usage scenarios where the names in the XML documents being parsed are mostly unique by installing a memory sensitive SymbolTable.
This is the "standard" parser configuration.
An XMLInputSource analogue to javax.xml.transform.stax.StAXSource.
A light wrapper around a StAX location.
StringValidator validates that XML content is a W3C string type.
Represent the schema type "string"
Contains a list of Strings.
To store and validate information about substitutionGroup
This class is an unsynchronized hash table primarily used for String to Object mapping.
This class is a key table entry.
This class is a symbol table implementation that guarantees that strings used as identifiers are unique references.
This class is a symbol table entry.
Synchronized symbol table.
Text nodes hold the non-markup, non-Entity content of an Element or Attribute.
Validator for <time> datatype (W3C Schema Datatypes)
This class implements the TreeWalker interface.
All primitive types plus ID/IDREF/ENTITY/INTEGER are derived from this abstract class.
Reader for UCS-2 and UCS-4 encodings.
An implementation of the DOM Level 2 UIEvent interface.
Represent the schema union types
Schema unique or key identity constraint.
A class to represent a Uniform Resource Identifier (URI).
MalformedURIExceptions are thrown in the process of building a URI or setting fields on a URI when an operation would result in an invalid URI specification.
A UTF-16 reader.
A UTF-8 reader.
Class to get the information back after content is validated.
ValidationContext has all the information required for the validation of: id, idref, entity, notation, qname
ValidationManager is a coordinator property for validators in the pipeline.
Implementation of the ValidationContext interface.
Interface for storing values associated to an identity constraint.
This class defines the version number of the parser.
This class is used for reading resources requested in <include> elements in XML 1.1 entities, when the parse attribute of the <include> element is "text".
This class is the configuration used to parse XML 1.0 and XML 1.1 documents and provides support for XInclude.
This is a pipeline component which performs XInclude handling, according to the W3C specification for XML Inclusions.
 
 
XIncludeMessageFormatter provides error messages for the XInclude 1.0 Candidate Recommendation
This is an implementation of NamespaceContext which is intended to be used for XInclude processing.
This parser configuration includes an XIncludeHandler in the pipeline before the schema validator, or as the last component in the pipeline if there is no schema validator.
This class is used for reading resources requested in <include> elements, when the parse attribute of the <include> element is "text".
This class defines the basic properties of characters in XML 1.1.
An XMLParserConfiguration implements this interface in order to indicate that it provides support for XML 1.1.
This class is the configuration used to parse XML 1.0 and XML 1.1 documents.
This class is responsible for scanning XML document structure and content.
This class is the DTD-only parser configuration used to parse XML 1.0 and XML 1.1 documents.
the factory to create/return built-in XML 1.1 DVs and create user-defined DVs
This class extends XMLDTDProcessor by giving it the ability to parse XML 1.1 documents correctly.
This class is responsible for scanning the declarations found in the internal and external subsets of a DTD in an XML document.
This allows the validator to correctlyhandle XML 1.1 documents.
Implements the entity scanner methods in the context of XML 1.1.
IDDatatypeValidator - ID represents the ID attribute type from XML 1.1 Recommendation.
IDREFDatatypeValidator - represents the IDREFS attribute type from XML 1.1 recommendation.
This class performs namespace binding on the startElement and endElement method calls in accordance with Namespaces in XML 1.1.
NMTOKEN datatype validator for NMTokens from XML 1.1.
This class is the non validating parser configuration used to parse XML 1.0 and XML 1.1 documents.
The scanner acts as the source for the document information which is communicated to the document handler.
The DTD validator.
The XMLAttributesImpl class is an implementation of the XMLAttributes interface which defines a collection of attributes for an element.
The catalog resolver handles the resolution of external identifiers and URI references through XML catalogs.
This class defines the basic XML character properties.
ContentSpec really exists to aid the parser classes in implementing access to the grammar.
Provides a means for walking the structure built out of content spec "nodes".
This class is responsible for scanning the structure and content of document fragments.
This interface defines an XML "event" dispatching model.
Element stack.
This is a concrete vanilla XML parser class.
This class is responsible for scanning XML document structure and content.
All information specific to DTD grammars.
The DTD loader.
The DTD processor.
This class is responsible for scanning the declarations found in the internal and external subsets of a DTD in an XML document.
The DTD validator.
Defines a DTD Validator filter to allow components to query the DTD validator.
This interface describes the properties of entities--their physical location and their name.
This class is an implementation of the XMLEntityDescription interface which describes the properties of an entity.
The entity handler interface defines methods to report information about the start and end of entities.
The entity manager handles the registration of general and parameter entities; resolves entities; and starts entities.
Entity information.
External entity.
Internal entity.
Implements the entity scanner methods.
This class is a common element of all parser configurations and is used to report errors that occur.
Implementation of XMLEventFactory.
This configuration provides a generic way of using Xerces's grammar caching facilities.
 
Stores grammars in a pool associated to a specific key.
This class is a grammar pool entry.
This class provides an easy way for a user to preparse grammars of various types.
A light wrapper around an XMLLocator.
XMLMessageFormatter provides error messages for the XML 1.0 Recommendation and for the Namespaces Recommendation
This class performs namespace binding on the startElement and endElement method calls and passes all other methods through to the registered document handler.
The scanner acts as the source for the document information which is communicated to the document handler.
The DTD validator.
Base class of all XML-related parsers.
The XMLResourceIdentifierImpl class is an implementation of the XMLResourceIdentifier interface which defines the location identity of a resource.
This class is responsible for holding scanning methods common to scanning the XML document structure and content as well as the DTD structure and content.
This exception might be thrown by any constraint checking method.
SchemaFactory for XML Schema.
This class implements xni.grammars.XMLGrammarLoader.
The XML Schema validator.
 
A simple vector for shorts.
Stack of XPath matchers for identity constraints.
XMLString is a structure used to pass character arrays.
All internalized xml symbols.
This class scans the version of the document to determine which scanner to use: XML 1.1 or XML 1.0.
Bare minimum XPath parser.
Axis.
A location path representation for an XPath expression.
Node test.
A location path step comprised of an axis and node test.
XPath exception.
XPath matcher.
This is a pipeline component which extends the XIncludeHandler to perform XPointer specific processing specified in the W3C XPointerFramework and element() Scheme Recommendations.
This parser configuration includes an XPointerHandler in the pipeline before the schema validator, or as the last component in the pipeline if there is no schema validator.
Used for scheme specific parsing and evaluation of an XPointer expression.
The XPointerProcessor is responsible for parsing an XPointer expression and and providing scheme specific resolution of the document fragment pointed to be the pointer.
Class defining utility/helper methods to support XML Schema 1.0 implementation.
XSAllCM implements XSCMValidator and handles <all>.
This is an implementation of the XSAnnotation schema component.
Class XSAttributeCheck is used to check the validity of attributes appearing in the schema document.
The XML representation for an attribute declaration schema component is an <attribute> element information item
The XML representation for an attribute group declaration schema component is a global <attributeGroup> element information item
The XML representation for an attribute use schema component is a local <attribute> element information item
Content model Bin-Op node.
Content model leaf node.
A compound content model leaf node which carries occurence information.
Content model Uni-Op node.
Note: State of the content model is stored in the validator
The XML representation for a complexType schema component is a <complexType> element information item
Constraints shared by traversers and validator
All information specific to XML Schema grammars.
This class is pool that enables caching of XML Schema declaration objects.
DFAContentModel is the implementation of XSCMValidator that does all of the non-trivial element content validation.
The purpose of this class is to co-ordinate the construction of a grammar object corresponding to a schema.
The XML representation for an element declaration schema component is an <element> element information item
XSEmptyCM is a derivative of the abstract content model base class that handles a content model with no children (elements).
A class used to hold the internal schema grammar set for the current instance
Add a method that return an XSModel that represents components in the schema grammars in this pool implementation.
A container for grammar pools which only contain schema grammars.
The XML representation for a group declaration schema component is a global <group> element information item
Implements XSImplementation interface that allows one to retrieve an instance of XSLoader.
An implementation of XSLoader which wraps XMLSchemaLoader.
SchemaMessageProvider implements an XMLMessageProvider that provides localizable error messages for the W3C XML Schema Language
Store schema model group declaration.
Implements XSModel: a read-only interface that represents an XML Schema, which could be components from different namespaces.
Contains the map between qnames and XSObject's.
Contains the map between qnames and XSObject's.
The XML representation for a NOTATION declaration schema component is a global <notation> element information item
Contains a list of XSObjects.
Store schema particle declaration.
This interface XSSimpleType represents the simple type definition of schema component and defines methods to query the information contained.
Base class for XSSimpleType wrapper implementations.
The XML representation for a wildcard declaration schema component is an <any> or <anyAttribute> element information item
Validator for <gYear> datatype (W3C Schema Datatypes)
Validator for <gYearMonth> datatype (W3C Schema Datatypes)