## 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, Serializable, 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.SimpleType
`VARIETY_ATOMIC, VARIETY_LIST, VARIETY_UNION, VARIETY_UNSPECIFIED_SIMPLE`

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(EnterpriseConfiguration config)` Create a new user-defined ListType.

Method Summary
`protected List<Facet>` `addInheritedFacets(List<Facet> localFacets)` Get the extended facet list, creating it if necessary.
`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(CharSequence value, NamespaceResolver resolver, ConversionRules rules)` 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` `isIdRefType()` Ask whether this type is an IDREF or IDREFS type.
`boolean` `isIdType()` Ask whether this type is an ID 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(CharSequence value, NamespaceResolver nsResolver, ConversionRules rules)` 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, postprocess, preprocess, 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, getRedefinitionLevel, getSchemaDocumentURI, getSystemId, getValidationStatus, lookForCycles, 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 net.sf.saxon.type.SimpleType
`getBuiltInBaseType, getWhitespaceAction, isExternalType, isUnionType, postprocess, preprocess`

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
`getRedefinitionLevel, getValidationStatus`

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

Constructor Detail

### UserListType

    public UserListType(EnterpriseConfiguration 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

### isIdType

    public boolean isIdType()

  Ask whether this type is an ID type. This is defined to be any simple type who typed value may contain atomic values of type xs:ID: that is, it includes types derived from ID by restriction, list, or union. Note that for a node to be treated as an ID in XSD 1.0, its typed value must be a *single* atomic value of type ID; the type of the node, however, can still allow a list. But in XSD 1.1, a list of IDs is permitted

  Specified by:
    `isIdType` in interface `SchemaType`
  Overrides:
    `isIdType` in class `UserSimpleType`

### isIdRefType

    public boolean isIdRefType()

  Ask whether this type is an IDREF or IDREFS type. This is defined to be any simple type who typed value may contain atomic values of type xs:IDREF: that is, it includes types derived from IDREF or IDREFS by restriction, list, or union

  Specified by:
    `isIdRefType` in interface `SchemaType`
  Overrides:
    `isIdRefType` in class `UserSimpleType`

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

### addInheritedFacets

    protected List<Facet> addInheritedFacets(List<Facet> localFacets)

  Get the extended facet list, creating it if necessary. The extended facet list includes facets inherited from supertypes, unless they are redundant

  Overrides:
    `addInheritedFacets` in class `UserSimpleType`
  Returns:
    the extended facet list

### 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(CharSequence value,
                                             NamespaceResolver nsResolver,
                                             ConversionRules rules)

  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.
    `rules` -
  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:
    `UnsupportedOperationException` - if the type is namespace-sensitive and no namespace resolver is supplied

### getTypedValue

    public SequenceIterator getTypedValue(CharSequence value,
                                          NamespaceResolver resolver,
                                          ConversionRules rules)
                                   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
    `rules` -
  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) 2004-2010 Saxonica Limited. All rights reserved.