com.saxonica.schema

## Class AttributeGroupReference

- java.lang.Object
- - com.saxonica.schema.SchemaStructure
  - - com.saxonica.schema.AttributeGroupReference

- All Implemented Interfaces:
    ComponentReference, Serializable, SourceLocator

      public final class AttributeGroupReference
      extends SchemaStructure
      implements ComponentReference

  An XML Schema Attribute Group Reference, corresponding to an xs:attributeGroup element with a 'ref' attribute.
  See Also:
    Serialized Form

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `AttributeGroupReference(EnterpriseConfiguration config, int fingerprint)` Creates a new AttributeGroup reference

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `elaborate(SchemaCompiler compiler)` Elaborate the schema component: after reloading a serialized schema component model, this expands the component with derived information needed during validation episodes.
    `boolean` | `fixup(SchemaCompiler compiler)` Fix up references to other elements in the schema.
    `AttributeWildcard` | `getAttributeWildcard(SchemaCompiler compiler)` Returns the attribute wildcard in the referenced attribute group, if any.
    `protected AttributeWildcard` | `getAttributeWildcard(SchemaCompiler compiler, Stack<AttributeGroupDecl> stack)`
    `int` | `getFingerprint()` Get the fingerprint of the target of this reference
    `int` | `getSymbolSpace()` Get the symbol space of the target of this reference
    `SchemaComponent` | `getTarget()` Resolves the attribute group reference Note this method doesn't bind irrevocably to the target attribute group declaration, because this may change following a redefine.
    `boolean` | `isResolved()` Determine whether this reference has been resolved
    `void` | `lookForCycles(Stack references, SchemaCompiler compiler)` Check for cycles in the attribute group.
    `void` | `setFingerprint(int fingerprint)` Set the fingerprint of the target of this reference
    `void` | `tryToResolve(SchemaCompiler compiler)` Attempt to resolve this reference using the groups defined in a given schema.
    `boolean` | `validate(SchemaCompiler compiler)` Checks the validity of this Schema component.

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

      `getColumnNumber, getConfiguration, getFixupStatus, getLineNumber, getPublicId, getRedefinitionLevel, getSchemaDocumentURI, getSystemId, getValidationStatus, makeXPathExpressionPropertyRecord, setConfiguration, setFixupStatus, setLineNumber, setLocator, setRedefinitionLevel, setSchemaDocumentURI, setSystemId, setValidationStatus`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

    - ### Methods inherited from interface com.saxonica.schema.ComponentReference

      `getConfiguration`

    - ### Methods inherited from interface javax.xml.transform.SourceLocator

      `getColumnNumber, getLineNumber, getPublicId, getSystemId`

- - ### Constructor Detail

    - #### AttributeGroupReference

          public AttributeGroupReference(EnterpriseConfiguration config,
                                 int fingerprint)

      Creates a new AttributeGroup reference
      Parameters:
        `config` - the Configuration that this AttributeGroup belongs to.
        `fingerprint` - The NamePool fingerprint of the name of the attribute group (that is, the name contained in the 'ref' attribute)

  - ### Method Detail

    - #### isResolved

          public boolean isResolved()

      Determine whether this reference has been resolved
      Specified by:
        `isResolved` in interface `ComponentReference`
      Returns:
        true if the reference has been resolved to a schema component

    - #### getSymbolSpace

          public int getSymbolSpace()

      Get the symbol space of the target of this reference
      Specified by:
        `getSymbolSpace` in interface `ComponentReference`
      Returns:
        an integer code identifying the symbol space

    - #### setFingerprint

          public void setFingerprint(int fingerprint)

      Set the fingerprint of the target of this reference
      Parameters:
        `fingerprint` - the integer code of the name of the attribute group

    - #### getFingerprint

          public int getFingerprint()

      Get the fingerprint of the target of this reference
      Specified by:
        `getFingerprint` in interface `ComponentReference`
      Returns:
        the integer code of the name of the attribute group

    - #### getAttributeWildcard

          public AttributeWildcard getAttributeWildcard(SchemaCompiler compiler)
                                                 throws UnresolvedReferenceException

      Returns the attribute wildcard in the referenced attribute group, if any.
      Parameters:
        `compiler` - May be null if used at validation time.
      Returns:
        the the attribute wildcard (xs:anyAttribute element) in the referenced attribute group, if there is one; otherwise null.
      Throws:
        `UnresolvedReferenceException` - if the reference to the attribute group declaration cannot be resolved

    - #### getAttributeWildcard

          protected AttributeWildcard getAttributeWildcard(SchemaCompiler compiler,
                                               Stack<AttributeGroupDecl> stack)
                                                    throws UnresolvedReferenceException

      Throws:
        `UnresolvedReferenceException`

    - #### fixup

          public boolean fixup(SchemaCompiler compiler)
                        throws SchemaException

      Fix up references to other elements in the schema.
      Overrides:
        `fixup` in class `SchemaStructure`
      Parameters:
        `compiler` - the schema compiler
      Returns:
        true if fixup succeeds, false if it fails.
      Throws:
        `SchemaException` - if a fatal error occurs

    - #### validate

          public boolean validate(SchemaCompiler compiler)
                           throws SchemaException

      Checks the validity of this Schema component. For internal use only.
      Parameters:
        `compiler` - the schema compiler
      Returns:
        true when this Schema definition is valid, otherwise false.
      Throws:
        `SchemaException`

    - #### lookForCycles

          public void lookForCycles(Stack references,
                           SchemaCompiler compiler)
                             throws SchemaException

      Check for cycles in the attribute group. For internal use only.
      Overrides:
        `lookForCycles` in class `SchemaStructure`
      Parameters:
        `references` - A list of attribute groups that reference this one, directly or indirectly.
        `compiler` - the schema compiler
      Throws:
        `SchemaException` - if a circularity is detected.

    - #### tryToResolve

          public void tryToResolve(SchemaCompiler compiler)

      Attempt to resolve this reference using the groups defined in a given schema. No error results if the reference cannot be resolved.
      Specified by:
        `tryToResolve` in interface `ComponentReference`
      Parameters:
        `compiler` - The compiler being used to compile the referring component. This is assumed to know about the schema containing the candidate target components for the reference. If null, the schema containing the reference is used.

    - #### getTarget

          public SchemaComponent getTarget()

      Resolves the attribute group reference Note this method doesn't bind irrevocably to the target attribute group declaration, because this may change following a redefine.
      Specified by:
        `getTarget` in interface `ComponentReference`
      Returns:
        the schema component if the reference has been resolved.
      Throws:
        `UnresolvedReferenceException` - if the reference has not been resolved. Note that this is an unchecked exception.

    - #### elaborate

          public void elaborate(SchemaCompiler compiler)
                         throws SchemaException

      Elaborate the schema component: after reloading a serialized schema component model, this expands the component with derived information needed during validation episodes. The model is assumed to be valid.
      Overrides:
        `elaborate` in class `SchemaStructure`
      Parameters:
        `compiler` - the schema compiler
      Throws:
        `SchemaException`

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