com.saxonica.schema

## Class Notation

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

- All Implemented Interfaces:
    SerializableSchemaComponent, UserSchemaComponent, Serializable, SourceLocator, SchemaComponent

      public class Notation
      extends SchemaStructure
      implements UserSchemaComponent, SerializableSchemaComponent

  A Notation Declaration Schema Component
  See Also:
    Serialized Form

- - ### Field Summary

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

      `COMPONENT_FUNCTION_TYPE, FIXED_UP, INCOMPLETE, INVALID, UNVALIDATED, VALIDATED, VALIDATING`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `Notation(EnterpriseConfiguration config, SourceLocator locator)` Creates a new Notation

  - ### 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)` Check references from this component to other components
    `FunctionItem` | `getComponentAsFunction()` Get the schema component in the form of a function item.
    `int` | `getFingerprint()` Get the notation name
    `String` | `getName()` Return the local name of this Notation.
    `String` | `getNotationPublicId()` Get the public identifier of the notation
    `String` | `getNotationSystemId()` Get the system identifier of the notation
    `String` | `getTargetNamespace()` Return the target namespace of this Notation
    `void` | `serialize(SchemaModelSerializer serializer)` Serialize the schema component
    `void` | `setNameCode(int nameCode)` Set the name code of the notation
    `void` | `setNotationPublicId(String publicId)` Set the public identifier of the notation
    `void` | `setNotationSystemId(String systemId)` Set the system identifier of the notation
    `boolean` | `validate(SchemaCompiler compiler)` Checks the validity of this Notation.

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

      `getColumnNumber, getConfiguration, getFixupStatus, getLineNumber, getPublicId, getRedefinitionLevel, getSchemaDocumentURI, getSystemId, getValidationStatus, lookForCycles, 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.UserSchemaComponent

      `lookForCycles`

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

      `getRedefinitionLevel, getValidationStatus`

- - ### Constructor Detail

    - #### Notation

          public Notation(EnterpriseConfiguration config,
                  SourceLocator locator)

      Creates a new Notation
      Parameters:
        `config` - the Configuration to which this Notation belongs
        `locator` - the location of the declaration in the schema document

  - ### Method Detail

    - #### setNameCode

          public void setNameCode(int nameCode)

      Set the name code of the notation
      Parameters:
        `nameCode` - the NamePool code for the notation name

    - #### getFingerprint

          public int getFingerprint()

      Get the notation name
      Returns:
        the name of the notation as a NamePool fingerprint. This combines the values of the {name} and {target namespace} properties in the schema component model.

    - #### setNotationSystemId

          public void setNotationSystemId(String systemId)

      Set the system identifier of the notation
      Parameters:
        `systemId` - the system identifier (possibly null)\

    - #### setNotationPublicId

          public void setNotationPublicId(String publicId)

      Set the public identifier of the notation
      Parameters:
        `publicId` - the public identifier (possibly null)\

    - #### getNotationSystemId

          public String getNotationSystemId()

      Get the system identifier of the notation
      Returns:
        the value of the {system identifier} property (possibly null).

    - #### getNotationPublicId

          public String getNotationPublicId()

      Get the public identifier of the notation
      Returns:
        the value of the {public identifier} property (possibly null)\

    - #### getName

          public String getName()

      Return the local name of this Notation.
      Returns:
        the value of the {local name} property of the Notation Declaration

    - #### getTargetNamespace

          public String getTargetNamespace()

      Return the target namespace of this Notation
      Returns:
        the value of the {target namespace} property of the Notation Declaration

    - #### validate

          public boolean validate(SchemaCompiler compiler)

      Checks the validity of this Notation. Always returns true for this implementation.
      Specified by:
        `validate` in interface `UserSchemaComponent`
      Returns:
        true when this Schema definition is valid, otherwise false.

    - #### 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` - the schema compiler
      Returns:
        true if all is well, false if errors found
      Throws:
        `SchemaException`

    - #### elaborate

          public 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. The model is assumed to be valid.
      Specified by:
        `elaborate` in interface `UserSchemaComponent`
      Overrides:
        `elaborate` in class `SchemaStructure`
      Parameters:
        `compiler` - The schema compiler

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

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