Package com.saxonica.ee.schema

## Class ElementDecl

- java.lang.Object
- - com.saxonica.ee.schema.SchemaStructure
  - - com.saxonica.ee.schema.ElementDecl

- All Implemented Interfaces:
    `ComponentWithValueConstraint`, `SerializableSchemaComponent`, `Term`, `UserSchemaComponent`, `javax.xml.transform.SourceLocator`, `Location`, `SchemaComponent`, `SchemaDeclaration`, `org.xml.sax.Locator`

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

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

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from interface net.sf.saxon.type.SchemaComponent

      `SchemaComponent.ValidationStatus`

  - ### Field Summary

    - ### Fields inherited from interface net.sf.saxon.type.SchemaComponent

      `COMPONENT_FUNCTION_TYPE`

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `ElementDecl​(EnterpriseConfiguration config, boolean global, javax.xml.transform.SourceLocator locator)` | Creates a new element declaration

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `void` | `addIdentityConstraint​(IdentityConstraintReference constraint)` | Adds the given IdentityConstraint to this element definition.
    `void` | `addSubstitutionGroupHead​(StructuredQName qName)` | Adds 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​(java.lang.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)
    `int` | `getBlock()` | Returns the value of the 'block' attribute for this element.
    `Function` | `getComponentAsFunction()` | Get the schema component in the form of a function item.
    `StructuredQName` | `getComponentName()` | Get the name of the schema component
    `UserComplexType` | `getContainingComplexType()` | Get the containing complex type.
    `ModelGroupDefinition` | `getContainingModelGroup()` | Get the containing named model group.
    `java.lang.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
    `AtomicSequence` | `getFixedValue()` | Returns the 'fixed' value defined for this element declaration.
    `java.lang.Comparable` | `getFixedValueComparisonKey()` | Return the Comparable that can be used to compare the "fixed" value against other values using XML Schema comparison semantics.
    `java.lang.String` | `getFixedValueLexicalForm()` | Return the lexical form of the "fixed" value defined for this element declaration.
    `java.util.List<IdentityConstraintReference>` | `getIdentityConstraints()` | Returns a list of the identity constraints defined within this element definition.
    `java.lang.String` | `getName()` | Returns the local name of this Element declaration.
    `NamespaceResolver` | `getNamespaceResolver()` | Get the namespace resolver used when the fixed or value constraints include lexical QNames
    `int` | `getSubstitutionGroupExclusions()` | Get the substitution group exclusions of this element, that is, the value of the applicable `final` or `finalDefault` attributes.
    `java.util.Collection<ElementDecl>` | `getSubstitutionGroupMembers()` | Get the known members of the substitution group of this element, as a Set containing the ElementDecl objects.
    `java.util.Set<ElementDecl>` | `getSubstitutionGroupOwners()` | Returns the head(s) of the substitutionGroup for this element declaration, or null if there are none.
    `java.lang.String` | `getTargetNamespace()` | Get the namespace URI of this element declaration.
    `SchemaType` | `getType()` | Returns the Schema Type (ComplexType or SimpleType) of this Element Declaration.
    `java.util.List<TypeAlternative>` | `getTypeAlternatives()` | Get the type alternatives defined for this element.
    `int` | `getTypeFingerprint()` | Get the namepool fingerprint of the name of the element's type.
    `ValueConstraint` | `getValueConstraint()` | Get the value constraint (fixed or default value) that applies to this element declaration, if any
    `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.
    `void` | `lookForCycles​(java.util.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` | `setContainingModelGroup​(ModelGroupDefinition type)` | Sets the containing model group.
    `void` | `setElementName​(StructuredQName elementName)` |
    `void` | `setElementName​(StructuredQName elementName, int fingerprint)` | Set the name of this element declaration
    `void` | `setFinalProhibitions​(int finalValue)` | Sets the value of the 'final' property, indicating which types of derivation are not allowed.
    `void` | `setGeneratedId​(java.lang.String id)` | Set the generated Id for 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.
    `void` | `setValueConstraint​(ValueConstraint vc)` | Set the value constraint (fixed or default value) that applies to this element declaration
    `java.lang.String` | `toString()` |
    `boolean` | `validate​(SchemaCompiler compiler)` | Check the validity (consistency) of this element definition.

    - ### Methods inherited from class com.saxonica.ee.schema.SchemaStructure

      `elaborate, getColumnNumber, getConfiguration, getFixupStatus, getGeneratedId, getLineNumber, getPublicId, getRedefinitionLevel, getSchemaDocumentURI, getSystemId, getValidationStatus, hasSameLocation, isValidationNeeded, makeXPathExpressionPropertyRecord, saveLocation, 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.ee.schema.ComponentWithValueConstraint

      `getDefaultValue, getDefaultValueConstraint, getDefaultValueLexicalForm, getFixedValueConstraint, getValueConstraintAsFunction`

    - ### Methods inherited from interface net.sf.saxon.type.SchemaComponent

      `getRedefinitionLevel, getValidationStatus`

    - ### Methods inherited from interface com.saxonica.ee.schema.UserSchemaComponent

      `elaborate`

- - ### Constructor Detail

    - #### ElementDecl

          public ElementDecl​(EnterpriseConfiguration config,
                             boolean global,
                             javax.xml.transform.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​(java.lang.String id)

      Set the generated Id for this element declaration
      Overrides:
        `setGeneratedId` in class `SchemaStructure`
      Parameters:
        `id` - the generated ID

    - #### setNamespaceResolver

          public void setNamespaceResolver​(NamespaceResolver resolver)

      Set the namespace resolver to be used
      Parameters:
        `resolver` - the namespace resolver

    - #### getNamespaceResolver

          public NamespaceResolver getNamespaceResolver()

      Description copied from interface: `ComponentWithValueConstraint`
      Get the namespace resolver used when the fixed or value constraints include lexical QNames
      Specified by:
        `getNamespaceResolver` in interface `ComponentWithValueConstraint`
      Returns:
        the namespace resolver for lexical QNames

    - #### 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

    - #### setContainingModelGroup

          public void setContainingModelGroup​(ModelGroupDefinition type)

      Sets the containing model group. For internal use only.
      Parameters:
        `type` - the named model group 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.

    - #### getValueConstraint

          public ValueConstraint getValueConstraint()

      Get the value constraint (fixed or default value) that applies to this element declaration, if any
      Specified by:
        `getValueConstraint` in interface `ComponentWithValueConstraint`
      Returns:
        the applicable value constraint if there is one, or null otherwise

    - #### getSubstitutionGroupExclusions

          public int getSubstitutionGroupExclusions()

      Get the substitution group exclusions of this element, that is, the value of the applicable `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

    - #### getContainingModelGroup

          public ModelGroupDefinition getContainingModelGroup()

      Get the containing named model group. 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 named model group (not as part of a complex type), returns the model group definition. Otherwise, returns null.
      Returns:
        the containing model group definition if there is one, otherwise null

    - #### getFixedValue

          public AtomicSequence getFixedValue()

      Returns the 'fixed' value defined for this element declaration.
      Specified by:
        `getFixedValue` in interface `ComponentWithValueConstraint`
      Returns:
        the fixed value for this element declaration, or null if no fixed value was specified.

    - #### getFixedValueLexicalForm

          public java.lang.String getFixedValueLexicalForm()

      Return the lexical form of the "fixed" value defined for this element declaration. This is the form as written in the source schema, after whitespace normalization
      Specified by:
        `getFixedValueLexicalForm` in interface `ComponentWithValueConstraint`
      Returns:
        the lexical form of the "fixed" value, or null if there is no fixed value

    - #### getFixedValueComparisonKey

          public java.lang.Comparable getFixedValueComparisonKey()

      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 java.util.List<IdentityConstraintReference> getIdentityConstraints()

      Returns a list of the identity constraints defined within this element definition. This corresponds to the {identity-constraint definitions} property in the schema component model.
      Returns:
        a list of of `IdentityConstraintReference` objects contained within this element declaration.

    - #### getDisplayName

          public java.lang.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 java.lang.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 java.lang.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 MissingComponentException

      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:
        `MissingComponentException` - if the reference from the element declaration to its type cannot be resolved.

    - #### getSubstitutionGroupOwners

          public java.util.Set<ElementDecl> getSubstitutionGroupOwners()
                                                                throws MissingComponentException

      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 an empty set if none is defined. These are the immediate parents in the substitution group lattice.
      Throws:
        `MissingComponentException` - if the element is a member of a substitution group but no declaration of the referenced element is (yet) available

    - #### getSubstitutionGroupMembers

          public java.util.Collection<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`

    - #### 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`

    - #### setValueConstraint

          public void setValueConstraint​(ValueConstraint vc)

      Set the value constraint (fixed or default value) that applies to this element declaration
      Specified by:
        `setValueConstraint` in interface `ComponentWithValueConstraint`
      Parameters:
        `vc` - the value constraint

    - #### 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

    - #### setElementName

          public void setElementName​(StructuredQName elementName,
                                     int fingerprint)

      Set the name of this element declaration
      Parameters:
        `elementName` - the element name

    - #### setElementName

          public void setElementName​(StructuredQName elementName)

    - #### getComponentName

          public StructuredQName getComponentName()

      Description copied from interface: `SchemaDeclaration`
      Get the name of the schema component
      Specified by:
        `getComponentName` in interface `SchemaDeclaration`
      Returns:
        the component name as a structured QName

    - #### 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

    - #### addSubstitutionGroupHead

          public void addSubstitutionGroupHead​(StructuredQName qName)

      Adds the name of the head of a substitutionGroup for this element definition. For internal use only.
      Parameters:
        `qName` - the name of the head of the substitutionGroup of this element definition.

    - #### 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
      Specified by:
        `hasTypeAlternatives` in interface `SchemaDeclaration`
      Returns:
        true if type alternatives have been defined

    - #### getTypeAlternatives

          public java.util.List<TypeAlternative> getTypeAlternatives()

      Get the type alternatives defined for this element. This should be called only after callling hasTypeAlternatives() to check that there are any.
      Returns:
        an ordered list of the type alternatives defined for this element declaration.

    - #### lookForCycles

          public void lookForCycles​(java.util.Stack references,
                                    SchemaCompiler compiler)
                             throws SchemaException

      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` - if cycles are found

    - #### fixup

          public boolean fixup​(SchemaCompiler compiler)
                        throws SchemaException

      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`

    - #### makeSchemaNodeTest

          public NodeTest makeSchemaNodeTest()
                                      throws MissingComponentException

      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`
      Throws:
        `MissingComponentException` - if the type of the declaration is not present in the schema.

    - #### 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)
                                   throws MissingComponentException

      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
      Throws:
        `MissingComponentException`

    - #### toString

          public java.lang.String toString()

      Overrides:
        `toString` in class `java.lang.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

    - #### getComponentAsFunction

          public Function getComponentAsFunction()

      Description copied from interface: `SchemaComponent`
      Get the schema component in the form of a function item. This allows schema information to be made visible to XSLT or XQuery code. The function makes available the contents of the schema component as defined in the XSD specification. The function takes a string as argument representing a property name, and returns the corresponding property of the schema component. There is also a property "class" which returns the kind of schema component, for example "Attribute Declaration".
      Specified by:
        `getComponentAsFunction` in interface `SchemaComponent`
      Returns:
        the schema component represented as a function from property names to property values.

    - #### equals

          public boolean equals​(java.lang.Object other)

      Overrides:
        `equals` in class `java.lang.Object`

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `java.lang.Object`