## com.saxonica.schema
Class UserListType

    java.lang.Object
      com.saxonica.schema.SchemaStructure
          com.saxonica.schema.UserDefinedType
              com.saxonica.schema.UserSimpleType
                  com.saxonica.schema.UserListType

All Implemented Interfaces:
  SerializableSchemaComponent, UserSchemaComponent, java.io.Serializable, javax.xml.transform.SourceLocator, ListType, SchemaComponent, SchemaType, SimpleType

    public class UserListType

extends UserSimpleType
implements ListType

Represents a SimpleType that is a list of a given SimpleType, known as its itemType. A ListType may be a restriction of another ListType; the itemType must either be an AtomicType or a UnionType whose members are not list types.

This class is not used to implement the built-in list types NMTOKENS, ENTITIES, IDREFS.

See Also:
  Serialized Form

Field Summary

Fields inherited from class com.saxonica.schema.UserDefinedType
`extendedTypes, finalProhibitions`

Fields inherited from interface net.sf.saxon.type.SchemaType
`DERIVATION_EXTENSION, DERIVATION_LIST, DERIVATION_RESTRICTION, DERIVATION_UNION, DERIVE_BY_SUBSTITUTION`

Fields inherited from interface net.sf.saxon.type.SchemaComponent
`FIXED_UP, INCOMPLETE, INVALID, UNVALIDATED, VALIDATED, VALIDATING`

Constructor Summary
`UserListType(SchemaAwareConfiguration config)` Create a new user-defined ListType.

Method Summary
`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.
`AtomicType` `getCommonAtomicType()` Get the most specific possible atomic type that all items in this SimpleType belong to
`SimpleType` `getItemType()` Returns the simpleType of the items in this ListType.
`TypeReference` `getItemTypeReference()` Get the reference to the item type of the list
`SequenceIterator` `getTypedValue(java.lang.CharSequence value, NamespaceResolver resolver, NameChecker nameChecker)` Get the typed value of a given input string.
`boolean` `isAtomicType()` Test whether this Simple Type is an atomic type
`boolean` `isBuiltInType()` Determine whether this is a built-in type or a user-defined type
`boolean` `isListType()` Returns true if this type is derived by list, or if it is derived by restriction from a list type, or if it is a union that contains a list as one of its members
`boolean` `isNamespaceSensitive()` Test whether this simple type is namespace-sensitive, that is, whether the item types is derived from xs:QName or xs:NOTATION
`void` `serializeVariety(SchemaModelSerializer serializer)` Serialize the schema component
`void` `setItemTypeReference(TypeReference type)` Sets the itemType for this ListType (the type of item that instances of this list type contain).
`ValidationFailure` `validateContent(java.lang.CharSequence value, NamespaceResolver nsResolver, NameChecker nameChecker)` Check whether a given input string is valid according to this SimpleType

Methods inherited from class com.saxonica.schema.UserSimpleType
`addFacet, analyzeContentExpression, applyWhitespaceNormalization, atomize, checkAgainstFacets, checkTypeDerivationIsOK, convertFacetValues, getBuiltInBaseType, getExtendedFacetList, getFacet, getFacets, getLocalFacetList, getTypedValue, getWhitespaceAction, isSimpleType, isTypeDerivationOK, isUnionType, mergeEnumerationFacets, serialize, setFacetList, validate`

Methods inherited from class com.saxonica.schema.UserDefinedType

`allowsDerivation, containingDeclarationIsElement, getBaseType, getBaseTypeFingerprint, getBaseTypeReference, getBlock, getContainingDeclarationName, getDerivationMethod, getDescription, getDisplayName, getFingerprint, getLocalName, getName, getNameCode, getNamePool, getTargetNamespace, hasRegisteredExtension, isAnonymousType, isComplexType, isExternalType, isSameType, iterateExtensionTypes, registerExtensionType, setBaseTypeReference, setContainingDeclaration, setDerivationMethod, setDerivationMethodName, setExtendedTypes, setFinalProhibitions, setNameCode`

Methods inherited from class com.saxonica.schema.SchemaStructure
`fixup, getColumnNumber, getConfiguration, getFixupStatus, getLineNumber, getPublicId, getSystemId, getValidationStatus, lookForCycles, setConfiguration, setFixupStatus, setLineNumber, setLocator, setSystemId, setValidationStatus`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Methods inherited from interface net.sf.saxon.type.SimpleType
`getBuiltInBaseType, getWhitespaceAction, isExternalType, isUnionType`

Methods inherited from interface net.sf.saxon.type.SchemaType
`allowsDerivation, analyzeContentExpression, atomize, checkTypeDerivationIsOK, getBaseType, getBlock, getDerivationMethod, getDescription, getDisplayName, getFingerprint, getName, getNameCode, getSystemId, getTargetNamespace, getTypedValue, isAnonymousType, isComplexType, isSameType, isSimpleType`

Methods inherited from interface net.sf.saxon.type.SchemaComponent
`getValidationStatus`

Methods inherited from interface com.saxonica.schema.UserSchemaComponent
`fixup, lookForCycles`

Constructor Detail

### UserListType

    public UserListType(SchemaAwareConfiguration config)

  Create a new user-defined ListType.

  Parameters:
    `config` - the Saxon configuration

Method Detail

### isAtomicType

    public boolean isAtomicType()

  Test whether this Simple Type is an atomic type

  Specified by:
    `isAtomicType` in interface `SchemaType`
  Specified by:
    `isAtomicType` in interface `SimpleType`
  Overrides:
    `isAtomicType` in class `UserSimpleType`
  Returns:
    false, this is not an atomic type

### isBuiltInType

    public boolean isBuiltInType()

  Determine whether this is a built-in type or a user-defined type

  Specified by:
    `isBuiltInType` in interface `SimpleType`
  Returns:
    true if this is a built-in type

### isListType

    public boolean isListType()

  Returns true if this type is derived by list, or if it is derived by restriction from a list type, or if it is a union that contains a list as one of its members

  Specified by:
    `isListType` in interface `SimpleType`
  Overrides:
    `isListType` in class `UserSimpleType`
  Returns:
    true if this is a list type

### elaborate

    public void elaborate(SchemaCompiler compiler)
                   throws SchemaException

  Description copied from class: `UserSimpleType`
  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 `UserSimpleType`
  Throws:
    `SchemaException`

### getItemTypeReference

    public TypeReference getItemTypeReference()

  Get the reference to the item type of the list

  Returns:
    the type reference

### getItemType

    public SimpleType getItemType()
                           throws UnresolvedReferenceException

  Returns the simpleType of the items in this ListType. This method assumes that the item type has been fully resolved

  Specified by:
    `getItemType` in interface `ListType`
  Returns:
    the simpleType of the items in this ListType. This will either be an AtomicType or a UnionType
  Throws:
    `UnresolvedReferenceException` - if the item type has not been fully resolved

### getCommonAtomicType

    public AtomicType getCommonAtomicType()

  Get the most specific possible atomic type that all items in this SimpleType belong to

  Specified by:
    `getCommonAtomicType` in interface `SimpleType`
  Returns:
    the lowest common supertype of all member types

### setItemTypeReference

    public void setItemTypeReference(TypeReference type)

  Sets the itemType for this ListType (the type of item that instances of this list type contain). For internal use only.

  Parameters:
    `type` - the SimpleType for this ListType.

### validateContent

    public ValidationFailure validateContent(java.lang.CharSequence value,
                                             NamespaceResolver nsResolver,
                                             NameChecker nameChecker)

  Check whether a given input string is valid according to this SimpleType

  Specified by:
    `validateContent` in interface `SimpleType`
  Parameters:
    `value` - the input string to be checked
    `nsResolver` - a namespace resolver used to resolve namespace prefixes if the type is namespace sensitive. The value supplied may be null; in this case any namespace-sensitive content will throw an UnsupportedOperationException.
    `nameChecker` - XML 1.0 or 1.1 name checker, needed when validating against version-sensitive types such as xs:NCName
  Returns:
    null if validation succeeds; return a ValidationException describing the validation failure if validation fails, unless throwException is true, in which case the exception is thrown rather than being returned.
  Throws:
    `java.lang.UnsupportedOperationException` - if the type is namespace-sensitive and no namespace resolver is supplied

### getTypedValue

    public SequenceIterator getTypedValue(java.lang.CharSequence value,
                                          NamespaceResolver resolver,
                                          NameChecker nameChecker)
                                   throws ValidationException

  Get the typed value of a given input string. This method assumes that the input value is valid according to this SimpleType

  Specified by:
    `getTypedValue` in interface `SimpleType`
  Parameters:
    `value` - the string whose typed value is required
    `resolver` - namespace resolver
    `nameChecker` - XML 1.0 or 1.1 name checker
  Returns:
    an iterator over the atomic sequence comprising the typed value. The objects returned by this SequenceIterator will all be of type `AtomicValue`, The next() method on the iterator throws no checked exceptions, although it is not actually declared as an UnfailingIterator.
  Throws:
    `ValidationException` - if the supplied value is not in the lexical space of the data type

### isNamespaceSensitive

    public boolean isNamespaceSensitive()

  Test whether this simple type is namespace-sensitive, that is, whether the item types is derived from xs:QName or xs:NOTATION

  Specified by:
    `isNamespaceSensitive` in interface `SimpleType`
  Returns:
    true if the item type is derived from xs:QName or xs:NOTATION

### serializeVariety

    public void serializeVariety(SchemaModelSerializer serializer)
                          throws XPathException

  Serialize the schema component

  Specified by:
    `serializeVariety` in class `UserSimpleType`
  Throws:
    `XPathException`

Copyright (c) Saxonica Limited. All rights reserved.