All Classes and Interfaces
Class
Description
This exception will be thrown when the schema parsing is aborted
after all the errors are reported through GrammarReaderController.
Base implementation for various Verifier implementations.
exposes the low-level validation engine interface.
A state that can have <anyAttribute > element must implement this interface.
used to parse <anyAttribute > element.
used to parse <any > element.
special Token that matchs any element.
a NameClass that matches any name.
place holder for <anyOtherElement> of RELAX.
parses <anyOtherElement> state.
IslandVerifier that validates <anyOtherElement /> of RELAX.
base implementation of AnyAttributeState and AnyElementState.
'attPool' of RELAX module.
parses <ref role="..." />.
parses <attPool> element.
global attribute declaration.
Attribute declaration.
Feeds AttributeToken to the expression and obtains the residual (content model).
attribute group declaration.
parses <attributeGroup /> element.
removes all unnecessary expressions and
creates an expression that consists of required attributes and choices only.
Creates an expression whose AttributeExp is completely replaced by nullSet.
Creates an expression whose AttributeExp is completely replaced by epsilon.
parses <attribute> element.
parses <attribute> pattern.
parses <attribute> pattern.
used to parse <attribute > element.
represents attribute and its value.
Attribute wildcard property of the schema component.
Processes the attribtue wildcard according to the spec.
Schema component with
AttributeWildcardBase implementation for those expression which has two child expressions.
RELAX NG built-in datatypes.
state that has no children.
A|B.
Union of two NameClasses.
state that creates ChoiceExp.
creates "combined child content expression" and gathers "elements of concern"
and its "attribute-pruned" content model.
RELAX NG DTD compatibility datatype library.
parses <attribute> pattern.
Accept that is used when more than one pattern can be applicable to the current context.
base implementation of ComplexAcceptor.
used to parse restriction/extension element as a child of complexContent element.
parses <complexContent> element.
used to parse <complexType> element.
ComplexType definition.
<concur> pattern of TREX.
parses <concur> pattern.
Constant values related to JARV.
Adapt SAX2 ContentHandler as a SAX1 DocumentHandler.
base implementation for SimpleAcceptor and ComplexAcceptor
Non-recursive ReferenceExpRemover with a cache.
Internal view of GrammarReaderController.
Expression that matchs characters of the particular
Datatype.parses <param> element inside <data> element.
parses <data> pattern.
parses <data> pattern.
reference to
Datatypethis class is used to parse foreign datatype vocabulary.
a map from namespace URI to DataTypeVocabulary
makes sure that no two AttributeExps have the same attribute name as their target.
GrammarReaderController that prints all errors and warnings.
Implementation of ElementDecl interface by MSV grammar model.
parses <define> declaration.
parses <define> declaration.
parses <define> declaration.
<difference> name class.
Used to parse merged grammars.
parses <div> element under <module> element.
DocumentBuilderFactory implementation that supports validation.
Represents a kind of "constraint" over XML document.
SAX DocumentHandler event interceptor.
builds DOM from SAX2 event stream.
A GrammarReaderController2 may already have a DOM element for an imported schema.
implementation class for an LSInput where the only data source is an existing DOM element.
visits all DOM elements in the depth-first order (in-order).
command line Verifier.
All DTD parsing events are signaled through this interface.
do-nothing implementation of DTDEventHandler.
This implements parsing of XML 1.0 DTDs.
constructs
TREXGrammar object that exactly matches to
the parsed DTD.Element declaration.
XML Schema version of
ElementExp.used to parse <element > element without ref attribute.
Element declaration.
<element> pattern of TREX.
parses <ref label="..." /> element.
used to parse <element > element with ref attribute.
ElementRule declaration of RELAX.
Set of ElementRule objects that share the label name.
parses <elementRule> without 'type' attribute.
parses <elementRule> with 'type' attribute.
Collects "elements of concern".
parses <element> pattern.
parses <element> pattern.
a token that represents an XML element.
A schema in a DOM Element.
'emptyString' type of RELAX.
wraps ISORELAX ErrorHandler by VerificationErrorHandler interface.
default implementation of ErrorHandler.
Instances of this class is attached to
ValidityViolation to
provide detailed information about the error.Bad attribute.
Bad tag name.
Bad text.
Base class for element related errors.
This error occurs when MSV sees an end tag unexpectedly.
Missing attribute.
exportable Expression.
the purpose of this function object is to make sure
that the expression does not contain references to modules
other than one specified by this variable.
Primitive of the tree regular expression.
Acceptor implementation.clones an expression.
Base class for "finding" something from an expression.
interface that must be implemented by the parent state of ExpressionState.
Creates a new Expression by combining existing expressions.
expression cache by closed hash.
creates a string representation of the expression.
Base implementation for those states who read tags representing an expression.
Visitor interface for Expression and its derived types.
ExpressionVisitor that returns boolean.
ExpressionVisitor that returns Expression object.
ExpressionVisitor that returns void.
Visits all reachable expressions but do nothing.
State that parses Expression which contains other expressions.
Base implementation for those states who cannot have any children.
place holder for imported attributes declaration.
place holder for imported element declaration.
state that reads facets.
Interface implemented by the parent state of FacetState.
base implementation of RELAXFactoryImpl and TREXFactoryImpl
represents one field of an identity constraint.
XPath matcher that tests one field of a key.
Coordinator of FieldMatcher.
feeds SAX events to two ContentHandlers.
State that parses global declarations.
base interface of the "grammar".
loads any supported grammar (except XML DTD)
by automatically detecting the schema language.
base implementation of grammar readers that read grammar from SAX2 stream.
namespace prefix to URI conversion map.
Event notification interface for controlling grammar parsing process.
parses <grammar> element.
parses <grammar> element.
parses <grammar> element.
Converter from AGM to the XML representation.
model group declaration.
used to parse <group> element.
parses <hedgeRef label="..." /> element.
Base implementation for HedgeRuleState and TopLevelState.
hedgeRule of RELAX module.
parses <hedgeRule> element
this class is used as the base class of TopLevelState
makes sure that ID/IDREF are not abused.
Verifier with XML Schema-related enforcement.
Deprecated.
ValidationContextProvider that supports limited ID/IDREF implementation.
Wraps
IDContextProvider so that it can be used
where IDContextProvider2 is expected.represents an identity constraint.
used to parse <unique>,<key>, and <keyref> element.
Default implementation of GrammarReaderController.
do-nothing implementation of ErrorHandler.
state that ignores the entire subtree.
used to parse <import> element.
parses <include> element of RELAX Namespace.
<include> element as an immediate child of <grammar> element.
parses <include> element as a child of <grammar> element.
parses <include> element of RELAX Core.
<include> element in the pattern.
used to parse <include> element.
parses <element> element.
parses <tag> element inlined in <elementRule>
This is how the parser talks to its input entities, of all kinds.
parses <interface> element and <div> in interface.
<interleave> pattern of TREX, or <all> particle of XML Schema.
state that creates an InterleaveExp.
base implementation of IslandSchema for MSV.
replaces all ExternalElementExp and ExternalAttributeExp
by actual definitions.
Interface of verifier.
key constraint.
keyref constraint.
Special name class implementation used for the wild card of the "lax" mode.
light-weight stack implementation.
<list> of RELAX NG.
state that parses <list> element of XSD.
state that parses <list> pattern of RELAX NG.
localizes messages
a NameClass that accepts any tag name as long as its local part is specified name.
Base abstract implementation of XPath matcher.
This class provides support for multi-language string lookup, as needed
to localize messages from applications supporting multiple languages
at the same time.
<mixed> of RELAX.
parses <mixed> element.
parses <mixed> pattern.
Used to parse module.
parses <module> element.
An utility class that
reads multiple XML Schema documents and combines them into one schema object.
validator of (namespaceURI,localPart) pair.
common interface of AttributeExp and ElementExp.
Base implementation for ElementState and AttributeState
This class collects one name class and patterns
parses <anyName> name class.
parses <choice> name class.
Computes if two name classes collide or not.
Abstract implementation of a function
parses <difference> name class.
parses <name> name class.
parses <not> name class.
parses <nsName> name class.
Minimizes a name class.
Base implementation for NameClass primitives
Visitor interface for NameClass.
parses name class that has child name classes
Base implementation for those states who cannot have any child name class.
Visits NameClass and writes its XML representation.
NameClass that matchs any names in a particular namespace.
parses <namespace> element of RELAX Namespace.
parses <anyName> name class.
Parsing state for <anyName>
Parsing state for <nsName>
'none' datatype of RELAX.
NameClass that acts a not operator.
Used to mark a occurrence constraint which cannot
be easily represented by primitive expressions.
A+.
parses <oneOrMore> pattern.
parses <optional> pattern.
Base class for application-specific AGM annotation.
Base implementation of XPath matching engine.
Visits Expression and writes it as RELAX NG.
computes the possible names.
state that parses redefinable declaration.
declaration that can be redefined by using <redefine> element.
used to parse <redefine> element.
DocumentDeclaration implementation
Grammar object can be shared among multiple threads, but this object
cannot be shared.Container of ReferenceExp.
Reference to the other expression.
removes all ReferenceExp from AGM.
parses <ref> pattern.
parses <ref> pattern.
VerifierFactory implementation of RELAX Core.
reads RELAX-Namespace-extended RELAX Core.
reads RELAX module (classic RELAX module; no namespace extension)
by SAX2 and constructs abstract grammar model.
Visitor interface for RELAX expressions.
RELAX version of
ExpressionVisitorBoolean.RELAX version of
ExpressionVisitorExpressionRELAX Version of
ExpressionVisitorVoid"Grammar" of RELAX Namespace.
IslandSchema implementation for RELAX module.
"Module" of RELAX Core.
reads RELAX NG grammar with DTD compatibility annotation
and constructs abstract grammar model.
creates various State object, which in turn parses grammar.
VerifierFactory implementation of RELAX NG.
Grammar for RELAX NG (with DTD compatibility annotation).
reads RELAX NG grammar from SAX2 and constructs abstract grammar model.
information necessary to correctly parse pattern definitions.
creates various State object, which in turn parses grammar.
converts any Grammar into RELAX NG XML representation through SAX1 events.
parses RELAX Namespace XML and constructs a SchemaProvider.
reads RELAX grammar/module by SAX2 and constructs abstract grammar model.
creates various State object, which in turn parses grammar.
ErrorHandler that reports all errors and warnings.computes regular expression derivative.
This entity resolver class provides a number of utilities which can help
managment of external parsed entities in XML.
Checks RELAX NG contextual restrictions defined in the section 7.
state that parses <restriction> element.
invokes State object that parses the document element.
parses the root state of a grammar included as a pattern.
used to parse root of schema document.
parses root state of a merged grammar.
invokes State object that parses the document element.
RootIncludedSchemaState + final wrap up.
Acceptor that is used to validate root node of the island.
makes sure that the expression does not run away.
produces SAX2 event from a DOM tree.
SAXParserFactory implementation that supports validation.
This class is used to wrap SAXException by RuntimeException.
base implementation of RELAXFactoryImpl and TREXFactoryImpl
used to parse <schema> element of included schema.
implementation of SchemaProvider by using RELAX Grammar.
used to parse <schema> element.
XPath matcher that tests the selector of an identity constraint.
A,B.
state that creates SequenceExp.
Acceptor that will be used when only one ElementExp matches
the start tag.
used to parse extension element as a child of <simpleContent> element.
used to parse restriction/extension element as a child of <simpleContent> element.
used to parse <simpleContent> element.
a NameClass that accepts only one fixed name.
base interface of the most of parsing states.
Simple type declaration.
State that parses <simpleType> element and its children.
ElementExp that is used for <any processContents="skip"/>.
parses <start> declaration.
parses <start> element.
immutable start tag information
base interface of 'parsing state'.
calculates how character literals should be treated.
pair of Strings.
reference to String.
parses <string> pattern.
chunk of string.
'tag' of RELAX module.
parses <tag> element.
State that always returns the same expression.
VerifierFactory implementation that automatically detects the schema language.
primitive unit of XML instance.
parses <topLevel> element.
reads TREX grammar from SAX2 and constructs abstract grammar model.
creates various State object, which in turn parses grammar.
VerifierFactory implementation for TREX.
TREX grammar, which is expressed as <grammar> element.
reads TREX grammar from SAX2 and constructs abstract grammar model.
creates various State object, which in turn parses grammar.
IslandSchema implementation for TREX pattern.
reads extended-TREX grammar (extended by RELAX Namespace)
and constructs IslandSchema.
makes sure that there is no sequenced string.
Receives notification of the typed content of the document.
ElementPattern with type.
reads <element> element with 'label' annotation.
assign types to the incoming SAX2 events and reports them to
the application handler through TypedContentHandler.
reads TREX grammar with 'label' annotation.
State can implement this method to be notified by DataType vocabulary
about the result of parsing.
Base implementation for those expression who has one child expresison.
State that parses <union> element and its children.
unique constraint.
Collection of utility methods.
Exception that signals error was fatal and recovery was not possible.
Contains information about where and how validity violation was happened.
Expression that matchs a particular value of a
Datatype.parses <value> pattern.
SAX ContentHandler that verifies incoming SAX event stream.
SAX XMLFilter that verifies incoming SAX event stream.
Catch error messages and resolve schema locations.
A utility class that reads all the schemas from a WSDL.
Methods in this class are used to determine whether characters may
appear in certain roles in XML documents.
This class contains static methods used to determine whether identifiers
may appear in certain roles in XML documents.
set of XML Schema.
parses XML representation of XML Schema and constructs AGM.
creates various State object, which in turn parses grammar.
XML Schema object.
Base class of
ComplexTypeExp and SimpleTypeExp.Helper class that wraps
DocumentHandler and provides utility methods.internal representation of XPath ('aaa/bbb/ccc/ ...
Acceptor implementation for XSREDocDecl.
A wrapper of XSDatatype that serves as an expression
and encapsulates lazy-constructed datatypes.
this object renders the actual datatype object.
this object is used to keep the information about
the dependency between late-bind datatype objects.
Resolves a datatype name to the corresponding XSDatatypeExp object.
XSD implementation of
DataTypeVocabulary.VerifierFactory implementation for XML Schema.
REDocumentDeclaration that supports several W3C XML Schema
specific semantics.Interface for the type incubator.
Type owner for XML Schema datatypes.
parses <zeroOrMore> pattern.
IDContextProvider2.