com.saxonica.schema
Class ElementDecl

java.lang.Object
  extended by com.saxonica.schema.SchemaStructure
      extended by com.saxonica.schema.ElementDecl
All Implemented Interfaces:
SerializableSchemaComponent, Term, UserSchemaComponent, Serializable, SourceLocator, SchemaComponent, SchemaDeclaration

public class ElementDecl
extends SchemaStructure
implements UserSchemaComponent, SerializableSchemaComponent, SchemaDeclaration, Term

The object represents an element declaration in the schema. It may be a global element declaration, or a local element declaration.

See Also:
Serialized Form

Field Summary
 
Fields inherited from interface net.sf.saxon.type.SchemaComponent
FIXED_UP, INCOMPLETE, INVALID, UNVALIDATED, VALIDATED, VALIDATING
 
Constructor Summary
ElementDecl(EnterpriseConfiguration config, boolean global, SourceLocator locator)
          Creates a new element declaration
 
Method Summary
 void addIdentityConstraint(IdentityConstraintReference constraint)
          Adds the given IdentityConstraint to this element definition.
 void addSubstitutionGroupHead(int nameCode)
          Adds the fingerprint of the name of the head of a substitutionGroup for this element definition.
 void addSubstitutionGroupMember(ElementDecl member, SchemaCompiler compiler)
          Add a member of the substitution group that has this element as its head.
 void addTypeAlternative(TypeAlternative alternative)
          Add a type alternative to the type alternative table.
 boolean allowsDerivation(int derivation)
          Determines whether derivation (of a particular kind) from this type is allowed, based on the "final" property (that is, the {substitution group exclusions} in the component model
 boolean equals(Object other)
           
 boolean fixup(SchemaCompiler compiler)
          Check references from this component to other components
protected  void fixupSubstitutionGroup(SchemaCompiler compiler)
          Fix up the reference(s) to the head(s) of the substitition group(s)
 void gatherSubstitutionGroupOwnersTransitively(Set<ElementDecl> headSet)
          Get the heads of all substitution groups, expanded transitively (including this element declaration itself)
 int getBlock()
          Returns the value of the 'block' attribute for this element.
 UserComplexType getContainingComplexType()
          Get the containing complex type.
 String getDefaultValue()
          Returns the default value defined for this element definition.
 String getDisplayName()
          Returns the name of this Element declaration in a form suitable for error messages.
 int getFingerprint()
          Get the fingerprint of the name of this element declaration in the namePool
 Value getFixedValue()
          Returns the 'fixed' value defined for this element declaration.
 Comparable getFixedValueComparable()
          Return the Comparable that can be used to compare the "fixed" value against other values using XML Schema comparison semantics.
 String getFixedValueLexicalRepresentation()
          Return the canonical lexical representation of the "fixed" value defined for this element declaration
 Iterator<IdentityConstraintReference> getIdentityConstraints()
          Returns an Iterator over the identity constraints defined within this element definition.
 String getName()
          Returns the local name of this Element declaration.
 int getNameCode()
          Get the nameCode of the name of this element declaration in the namePool
 int getSubstitutionGroupExclusions()
          Get the substitution group exclusions of this element, that is, the value of the applcable final or finalDefault attributes.
 Set<ElementDecl> getSubstitutionGroupMembers()
          Get the known members of the substitution group of this element, as a Set containing the ElementDecl objects.
 Set<ElementDecl> getSubstitutionGroupOwners()
          Returns the head(s) of the substitutionGroup for this element declaration, or null if there are none.
 String getTargetNamespace()
          Get the namespace URI of this element declaration.
 SchemaType getType()
          Returns the Schema Type (ComplexType or SimpleType) of this Element Declaration.
 int getTypeFingerprint()
          Get the namepool fingerprint of the name of the element's type.
 int hashCode()
           
 boolean hasSameTypeTable(ElementDecl other)
          Test whether this element declaration has "the same" type table as another element declaration
 boolean hasTypeAlternatives()
          Ask whether any type alternatives are defined for this element
 boolean isAbstract()
          Returns true if this element definition is abstract.
 boolean isGlobal()
          Determine whether this element declaration is global.
 boolean isNillable()
          Determine whether or not instances of this element definition permit xsi:nil to be set to "yes".
 boolean isSameDeclaration(ElementDecl other)
          Test whether this is the same declaration as another declaration.
 Iterator<ElementDecl> iterateSubstitutionGroup()
          Iterate over all the elements contained in the substitution group of which this element is the head.
 Iterator<TypeAlternative> iterateTypeAlternatives()
          Iterate over the type alternatives defined for this element.
 void lookForCycles(Stack references, SchemaCompiler compiler)
          This method is called to look for cycles.
 NodeTest makeSchemaNodeTest()
          Create a NodeTest that implements the semantics of schema-element(name) or schema-attribute(name) applied to this element or attribute declaration.
 void registerComplexTypeUsingThisElement(UserComplexType type)
          Register a complex type that contains this element as a particle.
 void serialize(SchemaModelSerializer serializer)
          Serialize the schema component
 void setAbstract(boolean isAbstract)
          Sets whether or not this element definition is abstract.
 void setBlock(int block)
          Sets the value of the 'block' attribute for this element For internal use only.
 void setContainingComplexType(UserComplexType type)
          Sets the containing complex type definition.
 void setDefaultValue(String value)
          Sets the 'default' value for this element declaration.
 void setFinalProhibitions(int finalValue)
          Sets the value of the 'final' property, indicating which types of derivation are not allowed.
 void setFixedValue(Value value)
          Sets the fixed value for this element definition.
 void setGeneratedId(String id)
          Set the generated Id for this element declaration
 void setNameCode(int nameCode)
          Set the name of this element declaration
 void setNamespaceResolver(NamespaceResolver resolver)
          Set the namespace resolver to be used
 void setNillable(boolean nillable)
          Sets whether or not instances of this element definition may set xsi:nil='true'.
 void setTypeReference(TypeReference type)
          Sets the schema type for this element declaration.
 String toString()
           
 boolean validate(SchemaCompiler compiler)
          Check the validity (consistency) of this element definition.
 
Methods inherited from class com.saxonica.schema.SchemaStructure
elaborate, getColumnNumber, getConfiguration, getFixupStatus, getLineNumber, getPublicId, getRedefinitionLevel, getSchemaDocumentURI, getSystemId, getValidationStatus, setConfiguration, setFixupStatus, setLineNumber, setLocator, setRedefinitionLevel, setSchemaDocumentURI, setSystemId, setValidationStatus
 
Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait
 
Methods inherited from interface com.saxonica.schema.UserSchemaComponent
elaborate
 
Methods inherited from interface net.sf.saxon.type.SchemaComponent
getRedefinitionLevel, getValidationStatus
 

Constructor Detail

ElementDecl

public ElementDecl(EnterpriseConfiguration config,
                   boolean global,
                   SourceLocator locator)
Creates a new element declaration

Parameters:
config - the Configuration to which this element declaration belongs
global - true if the element declaration is top-level
locator - identifies the location of the element declaration in the
Method Detail

setGeneratedId

public void setGeneratedId(String id)
Set the generated Id for this element declaration

Parameters:
id - the generated ID

setNamespaceResolver

public void setNamespaceResolver(NamespaceResolver resolver)
Set the namespace resolver to be used

Parameters:
resolver - the namespace resolver

addIdentityConstraint

public void addIdentityConstraint(IdentityConstraintReference constraint)
Adds the given IdentityConstraint to this element definition. For internal use only.

Parameters:
constraint - the IdentityConstraint to add.

setContainingComplexType

public void setContainingComplexType(UserComplexType type)
Sets the containing complex type definition. For internal use only.

Parameters:
type - the complex type containing this local element declaration

getBlock

public int getBlock()
Returns the value of the 'block' attribute for this element. This corresponds to the value of the {disallowed substitutions} property in the schema component model.

Returns:
the value of the block attribute, as a bit-significant integer using constants such as SchemaType.DERIVE_BY_SUBSTITUTION, indicating which kinds of derivation from this element declaration are blocked.

getDefaultValue

public String getDefaultValue()
Returns the default value defined for this element definition.

Returns:
the default value of this element definition, or null if no default was specified.

getSubstitutionGroupExclusions

public int getSubstitutionGroupExclusions()
Get the substitution group exclusions of this element, that is, the value of the applcable final or finalDefault attributes. Corresponds to the property {substitution group exclusions} in the schema component model.

Returns:
the substitution group exclusions, represented as a bit-significant integer, the relevant bits being SchemaType.DERIVATION_EXTENSION and SchemaType.DERIVATION_RESTRICTION

allowsDerivation

public boolean allowsDerivation(int derivation)
Determines whether derivation (of a particular kind) from this type is allowed, based on the "final" property (that is, the {substitution group exclusions} in the component model

Parameters:
derivation - the kind of derivation, e.g. SchemaType.DERIVATION_EXTENSION
Returns:
true if this kind of derivation is allowed

getContainingComplexType

public UserComplexType getContainingComplexType()
Get the containing complex type. This represents one aspect of the {scope} property defined in the schema component model. If the element is a local element declaration and is defined as part of a complex type (and not as part of a named model group), returns the complex type definition. Otherwise, returns null.

Returns:
the containing complex type definition if there is one, otherwise null

getFixedValue

public Value getFixedValue()
Returns the 'fixed' value defined for this element declaration.

Returns:
the fixed value for this element declaration, or null if no fixed value was specified.

getFixedValueLexicalRepresentation

public String getFixedValueLexicalRepresentation()
Return the canonical lexical representation of the "fixed" value defined for this element declaration

Returns:
the canonical lexical representation of the "fixed" value, or null if there is no fixed value

getFixedValueComparable

public Comparable getFixedValueComparable()
Return the Comparable that can be used to compare the "fixed" value against other values using XML Schema comparison semantics.

Returns:
the Comparable for the fixed value, or null if there is no fixed value

getIdentityConstraints

public Iterator<IdentityConstraintReference> getIdentityConstraints()
Returns an Iterator over the identity constraints defined within this element definition. This corresponds to the {identity-constraint definitions} property in the schema component model.

Returns:
an Iterator of IdentityConstraintReference objects contained within this element definition.

getDisplayName

public String getDisplayName()
Returns the name of this Element declaration in a form suitable for error messages. This will be the Clark name

Returns:
the name of this element declaration in Clark format

getName

public String getName()
Returns the local name of this Element declaration. The name returned, if not null, will be an NCName. This corresponds to the {name} property defined in the schema component model.

Returns:
the local name of this element declaration, if it is global, or null if it is anonymous

getTargetNamespace

public String getTargetNamespace()
Get the namespace URI of this element declaration. This corresponds to the {targetNamespace} property defined in the schema component model.

Returns:
the target namespace if the element declaration is global and the target namespace is not "absent". Return "" for a local element declaration or for a global element in a no-namespace schema.

getTypeFingerprint

public int getTypeFingerprint()
Get the namepool fingerprint of the name of the element's type.

Returns:
the fingerprint of the type, or -1 if none is available.

getType

public SchemaType getType()
                   throws UnresolvedReferenceException
Returns the Schema Type (ComplexType or SimpleType) of this Element Declaration. This corresponds to the {typeDefinition} property in the schema component model.

Specified by:
getType in interface SchemaDeclaration
Returns:
the Schema Type of this Element Declaration.
Throws:
UnresolvedReferenceException - if the reference from the element declaration to its type cannot be resolved.

getSubstitutionGroupOwners

public Set<ElementDecl> getSubstitutionGroupOwners()
                                            throws UnresolvedReferenceException
Returns the head(s) of the substitutionGroup for this element declaration, or null if there are none. This corresponds to the {substitution group affiliation} property in the schema component model.

Returns:
the element declarations representing the heads of the substitution groups in which this element declaration is a member, or null if none is defined. These are the immediate parents in the substitution group lattice.
Throws:
UnresolvedReferenceException - if the element is a member of a substitution group but no declaration of the referenced element is (yet) available

gatherSubstitutionGroupOwnersTransitively

public void gatherSubstitutionGroupOwnersTransitively(Set<ElementDecl> headSet)
Get the heads of all substitution groups, expanded transitively (including this element declaration itself)

Parameters:
headSet - the set into which the heads of all groups will be placed

getSubstitutionGroupMembers

public Set<ElementDecl> getSubstitutionGroupMembers()
Get the known members of the substitution group of this element, as a Set containing the ElementDecl objects. This includes all applicable element declarations in schemas compiled within the same Configuration as this schema.

Returns:
a set containing all the substitution group members, expanded transtively

addSubstitutionGroupMember

public void addSubstitutionGroupMember(ElementDecl member,
                                       SchemaCompiler compiler)
                                throws SchemaException
Add a member of the substitution group that has this element as its head. For internal use only.

This method may be called at any time, for example when a new schema is loaded as a result of validating an instance document. The method is therefore synchronized, since the schema may be used in several threads concurrently. Adding a new member to a substitution group means that all complex type definitions that include this element in their content model must be recompiled.

It is not possible to add to a substitution group once the element declaration has been used, either for validating a source document or for compiling stylesheets or schemas.

Parameters:
member - The element declaration to be added to the substitution group of which this element declaration is the head. Elements are added to each ancestor in the substitution group hierarchy.
compiler - used for error reporting
Throws:
SchemaException - if a fatal error occurs

registerComplexTypeUsingThisElement

public void registerComplexTypeUsingThisElement(UserComplexType type)
Register a complex type that contains this element as a particle. If new elements are added to the substitution group headed by this element, these complex types will need to be recompiled to permit the new substititution group members. For internal use only.

Parameters:
type - A complex type that contains this element as a particle.

isAbstract

public boolean isAbstract()
Returns true if this element definition is abstract. This corresponds to the {abstract} property in the schema component model.

Specified by:
isAbstract in interface SchemaDeclaration
Returns:
true if this element definition is abstract

isNillable

public boolean isNillable()
Determine whether or not instances of this element definition permit xsi:nil to be set to "yes". This corresponds to the {nillable} property in the schema component model.

Specified by:
isNillable in interface SchemaDeclaration
Returns:
true if instances conforming to this element definition may be nilled, and false otherwise.

isGlobal

public boolean isGlobal()
Determine whether this element declaration is global. This represents one aspect of the {scope} property defined in the schema data model.

Returns:
true if the element declaration is global, false if it is local

setAbstract

public void setAbstract(boolean isAbstract)
Sets whether or not this element definition is abstract. For internal use only.

Parameters:
isAbstract - a boolean: when true indicates that this element definition is abstract

setBlock

public void setBlock(int block)
Sets the value of the 'block' attribute for this element For internal use only.

Parameters:
block - the value of the block attribute for this element definition, indicating the types of derivation that are not allowed, as a bit-significant integer, using constants such as SchemaType.DERIVATION_EXTENSION

setDefaultValue

public void setDefaultValue(String value)
Sets the 'default' value for this element declaration. For internal use only.

Parameters:
value - the default value for this element declaration.

setFinalProhibitions

public void setFinalProhibitions(int finalValue)
Sets the value of the 'final' property, indicating which types of derivation are not allowed. For internal use only.

Parameters:
finalValue - the bit-significant code representing the final property, made up of values such as SchemaType.DERIVE_BY_SUBSTITUTION

setFixedValue

public void setFixedValue(Value value)
Sets the fixed value for this element definition. For internal use only.

Parameters:
value - the fixed value for this element definition. This is stored initially as the string value initially specified in the schema document; once the type of the element is known (during schema validation) this is replaced by the typed value.

setNillable

public void setNillable(boolean nillable)
Sets whether or not instances of this element definition may set xsi:nil='true'. For internal use only.

Parameters:
nillable - the flag when true indicates that instances of this element definition may be nilled

setNameCode

public void setNameCode(int nameCode)
Set the name of this element declaration

Parameters:
nameCode - the nameCode of the element name in the namePool

getFingerprint

public int getFingerprint()
Get the fingerprint of the name of this element declaration in the namePool

Specified by:
getFingerprint in interface SchemaDeclaration
Returns:
the fingerprint of the element name

getNameCode

public int getNameCode()
Get the nameCode of the name of this element declaration in the namePool

Returns:
the nameCode of the element name

addSubstitutionGroupHead

public void addSubstitutionGroupHead(int nameCode)
Adds the fingerprint of the name of the head of a substitutionGroup for this element definition. For internal use only.

Parameters:
nameCode - the nameCode of the name of the head of the substitutionGroup of this element definition.

iterateSubstitutionGroup

public Iterator<ElementDecl> iterateSubstitutionGroup()
Iterate over all the elements contained in the substitution group of which this element is the head. If this object represents an element reference, the iterator is over the substitution group of the referenced global element.

Returns:
an iterator giving access to the ElementDecl objects defining the members of the substitution group. This gives access to all the descendants in the substitution group hierarchy, not only the elements that explicitly name this element as their substitution group head.

setTypeReference

public void setTypeReference(TypeReference type)
Sets the schema type for this element declaration. For internal use only.

Parameters:
type - the schema type for this element declaration.

addTypeAlternative

public void addTypeAlternative(TypeAlternative alternative)
Add a type alternative to the type alternative table. Note that the order in which alternatives are added is significant.

Parameters:
alternative - the type alternative to be added

hasTypeAlternatives

public boolean hasTypeAlternatives()
Ask whether any type alternatives are defined for this element

Returns:
true if type alternatives have been defined

iterateTypeAlternatives

public Iterator<TypeAlternative> iterateTypeAlternatives()
Iterate over the type alternatives defined for this element. This should be called only after callling hasTypeAlternatives() to check that there are any.

Returns:
an iterator over the type alternatives defined for this element declaration. The items returned by this iterator are of class TypeAlternative

lookForCycles

public void lookForCycles(Stack references,
                          SchemaCompiler compiler)
                   throws SchemaException,
                          UnresolvedReferenceException
This method is called to look for cycles. The object implementing this method is required (a) to raise an exception if the object itself appears in the list of references, (b) to add itself to the list of references, and (c) to call the lookForCycles method on all the objects that it references.

In this particular case the cycles we are looking for are cycles in substitution group membership.

Specified by:
lookForCycles in interface UserSchemaComponent
Overrides:
lookForCycles in class SchemaStructure
Parameters:
references - A list of objects that contain direct or indirect references to this object, and that must therefore not be referred to from this object.
compiler - used for error reporting
Throws:
SchemaException
UnresolvedReferenceException

fixup

public boolean fixup(SchemaCompiler compiler)
              throws SchemaException,
                     UnresolvedReferenceException
Check references from this component to other components

Specified by:
fixup in interface UserSchemaComponent
Overrides:
fixup in class SchemaStructure
Parameters:
compiler - used for error reporting
Returns:
true if all is well, false if errors found
Throws:
SchemaException
UnresolvedReferenceException

makeSchemaNodeTest

public NodeTest makeSchemaNodeTest()
Create a NodeTest that implements the semantics of schema-element(name) or schema-attribute(name) applied to this element or attribute declaration.

Specified by:
makeSchemaNodeTest in interface SchemaDeclaration

validate

public boolean validate(SchemaCompiler compiler)
                 throws SchemaException
Check the validity (consistency) of this element definition.

Specified by:
validate in interface UserSchemaComponent
Parameters:
compiler - used for error reporting
Returns:
true if validation succeeded, false if errors were found.
Throws:
SchemaException - if an error is found and the error listener decides that the error is fatal

fixupSubstitutionGroup

protected void fixupSubstitutionGroup(SchemaCompiler compiler)
                               throws SchemaException
Fix up the reference(s) to the head(s) of the substitition group(s)

Parameters:
compiler - used for error reporting
Throws:
SchemaException - if any error occurs, for example a name that is referenced but not declared

isSameDeclaration

public boolean isSameDeclaration(ElementDecl other)
Test whether this is the same declaration as another declaration. They are considered to be the same declaration if they are derived from the same definition in the original XML representation (which can happen when there are multiple includes of the same file)

Parameters:
other - the declaration with which to compare this one
Returns:
true if the two declarations are the same

hasSameTypeTable

public boolean hasSameTypeTable(ElementDecl other)
Test whether this element declaration has "the same" type table as another element declaration

Parameters:
other - the other element declaration
Returns:
true if the type tables are the same, false if they are different

toString

public String toString()
Overrides:
toString in class Object

serialize

public void serialize(SchemaModelSerializer serializer)
               throws XPathException
Serialize the schema component

Specified by:
serialize in interface SerializableSchemaComponent
Parameters:
serializer - the object responsible for performing the serialization
Throws:
XPathException - if serialization fails

equals

public boolean equals(Object other)
Overrides:
equals in class Object

hashCode

public int hashCode()
Overrides:
hashCode in class Object


Copyright (c) 2004-2011 Saxonica Limited. All rights reserved.