Package com.saxonica.ee.schema

Class UserListType

    • Constructor Detail

      • UserListType

        public UserListType​(EnterpriseConfiguration config)
        Create a new user-defined ListType.
        Parameters:
        config - the Saxon configuration

    • Method Detail

      • isIdType

        public boolean isIdType()
                 throws MissingComponentException
        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
        Returns:
        true if this type is an ID type
        Throws:
        MissingComponentException

      • isIdRefType

        public boolean isIdRefType()
                    throws MissingComponentException
        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
        Returns:
        true if this type is an IDREF type
        Throws:
        MissingComponentException

      • 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 java.util.List<Facet> addInheritedFacets​(java.util.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

      • getItemTypeReference

        public TypeReference getItemTypeReference()
        Get the reference to the item type of the list
        Returns:
        the type reference

      • getItemType

        public SimpleType getItemType()
                       throws MissingComponentException
        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:
        MissingComponentException - if the item type has not been fully resolved

      • 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.

      • setTokenSeparator

        public void setTokenSeparator​(RegularExpression regex)
        Set the regular expression defined in saxon:separator for tokenizing the supplied value
        Parameters:
        regex - the regular expression

      • inheritSeparator

        public void inheritSeparator​(UserListType base)

      • validateContent

        public ValidationFailure validateContent​(java.lang.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 - the conversion rules used in this configuration
        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

      • checkAgainstListFacets

        public ValidationFailure checkAgainstListFacets​(java.lang.CharSequence value,
                                                NamespaceResolver nsResolver,
                                                ConversionRules rules,
                                                int count)
        Check whether a supplied value is valid against the facets defined on the list type. This method does NOT check that the items in the list are valid against the item type of the list
        Parameters:
        value - the supplied value
        nsResolver - the namespace context
        rules - the conversion rules
        count - the number of items in the list
        Returns:
        either null if the value is valid, or a ValidationFailure giving diagnostics

      • getTypedValue

        public AtomicSequence getTypedValue​(java.lang.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 - the conversion rules used in this configuration
        Returns:
        the typed value as an iterator
        Throws:
        ValidationException - if the input is invalid against this 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; or if the item type cannot be determined (because it is missing from the schema)

      • toString

        public java.lang.String toString()
        Produce a string representation of the type name. If the type is anonymous, an internally-allocated type name will be returned.
        Overrides:
        toString in class UserDefinedType
        Returns:
        the name of the atomic type in the form Q{uri}local