Class TypeChecker


  • public final class TypeChecker
    extends java.lang.Object
    This class provides Saxon's type checking capability. It contains a static method, staticTypeCheck, which is called at compile time to perform type checking of an expression. This class is never instantiated.
    • Method Detail

      • staticTypeCheck

        public static Expression staticTypeCheck​(Expression supplied,
                                                 SequenceType req,
                                                 boolean backwardsCompatible,
                                                 RoleLocator role,
                                                 TypeCheckerEnvironment visitor)
                                          throws XPathException
        Check an expression against a required type, modifying it if necessary.

        This method takes the supplied expression and checks to see whether it is known statically to conform to the specified type. There are three possible outcomes. If the static type of the expression is a subtype of the required type, the method returns the expression unchanged. If the static type of the expression is incompatible with the required type (for example, if the supplied type is integer and the required type is string) the method throws an exception (this results in a compile-time type error being reported). If the static type is a supertype of the required type, then a new expression is constructed that evaluates the original expression and checks the dynamic type of the result; this new expression is returned as the result of the method.

        The rules applied are those for function calling in XPath, that is, the rules that the argument of a function call must obey in relation to the signature of the function. Some contexts require slightly different rules (for example, operands of polymorphic operators such as "+"). In such cases this method cannot be used.

        Note that this method does not do recursive type-checking of the sub-expressions.

        Parameters:
        supplied - The expression to be type-checked
        req - The required type for the context in which the expression is used
        backwardsCompatible - True if XPath 1.0 backwards compatibility mode is applicable
        role - Information about the role of the subexpression within the containing expression, used to provide useful error messages
        visitor - An expression visitor
        Returns:
        The original expression if it is type-safe, or the expression wrapped in a run-time type checking expression if not.
        Throws:
        XPathException - if the supplied type is statically inconsistent with the required type (that is, if they have no common subtype)
      • testConformance

        public static XPathException testConformance​(ValueRepresentation val,
                                                     SequenceType requiredType,
                                                     XPathContext context)
                                              throws XPathException
        Test whether a given value conforms to a given type
        Parameters:
        val - the value
        requiredType - the required type
        context - XPath dynamic context
        Returns:
        an XPathException describing the error condition if the value doesn't conform; or null if it does.
        Throws:
        XPathException - if a failure occurs reading the value
      • ebvError

        public static XPathException ebvError​(Expression exp,
                                              TypeHierarchy th)
        Test whether a given expression is capable of returning a value that has an effective boolean value.
        Parameters:
        exp - the given expression
        th - the type hierarchy cache
        Returns:
        null if the expression is OK (optimistically), an exception object if not
      • applyFunctionConversionRules

        public static Value applyFunctionConversionRules​(ValueRepresentation value,
                                                         SequenceType requiredType,
                                                         RoleLocator role,
                                                         javax.xml.transform.SourceLocator locator,
                                                         XPathContext context)
                                                  throws XPathException
        Apply the function conversion rules to a value, given a required type. The parameter type S represents the supplied type, R the required type
        Parameters:
        value - a value to be converted
        requiredType - the required type
        context - the conversion context
        Returns:
        the converted value
        Throws:
        XPathException - if the value cannot be converted to the required type
      • applyFunctionConversionRules

        public static SequenceIterator applyFunctionConversionRules​(SequenceIterator input,
                                                                    ItemType suppliedItemType,
                                                                    SequenceType requiredType,
                                                                    RoleLocator role,
                                                                    javax.xml.transform.SourceLocator locator,
                                                                    XPathContext context)
                                                             throws XPathException
        Apply the function conversion rules to a value (represented as an iterator), given a required type. The parameter type S represents the supplied type, R the required type
        Parameters:
        input - a value to be converted
        suppliedItemType - the type of the items in the input
        requiredType - the required type
        context - the conversion context
        Returns:
        the converted value
        Throws:
        XPathException - if the value cannot be converted to the required type