Package net.sf.saxon.expr

Class UntypedSequenceConverter

    • Constructor Detail

      • UntypedSequenceConverter

        public UntypedSequenceConverter​(Expression sequence,
                                PlainType requiredItemType)
        Constructor
        Parameters:
        sequence - this must be a sequence of atomic values. This is not checked; a ClassCastException will occur if the precondition is not satisfied.
        requiredItemType - the item type to which all items in the sequence should be converted, using the rules for "cast as".

    • Method Detail

      • makeUntypedSequenceConverter

        public static UntypedSequenceConverter makeUntypedSequenceConverter​(Configuration config,
                                                                    Expression operand,
                                                                    PlainType requiredItemType)
                                                             throws XPathException
        Create an AtomicSequenceConverter that converts all untypedAtomic values in the input sequence to a specified target type, while leaving items other than untypedAtomic unchanged
        Parameters:
        config - the Saxon configuration
        operand - the expression that delivers the input sequence
        requiredItemType - the type to which untypedAtomic values should be cast, which must either be an atomic type or a "plain" union type
        Returns:
        an AtomicSequenceConverter that performs the required conversion
        Throws:
        XPathException - if an error occurs, for example if the target type is namespace-sensitive

      • typeCheck

        public Expression typeCheck​(ExpressionVisitor visitor,
                            ContextItemStaticInfo contextInfo)
                     throws XPathException
        Description copied from class: AtomicSequenceConverter
        Type-check the expression
        Overrides:
        typeCheck in class AtomicSequenceConverter
        Parameters:
        visitor - an expression visitor
        contextInfo - Information available statically about the context item: whether it is (possibly) absent; its static type; its streaming posture.
        Returns:
        the original expression, rewritten to perform necessary run-time type checks, and to perform other type-related optimizations
        Throws:
        XPathException - if an error is discovered during this phase (typically a type error)

      • copy

        public Expression copy​(RebindingMap rebindings)
        Copy an expression. This makes a deep copy.
        Overrides:
        copy in class AtomicSequenceConverter
        Parameters:
        rebindings - variables that need to be re-bound
        Returns:
        the copy of the original expression

      • getItemType

        public ItemType getItemType()
        Determine the data type of the items returned by the expression, if possible
        Overrides:
        getItemType in class AtomicSequenceConverter
        Returns:
        a value such as Type.STRING, Type.BOOLEAN, Type.NUMBER, Type.NODE, or Type.ITEM (meaning not known in advance)

      • equals

        public boolean equals​(java.lang.Object other)
        Is this expression the same as another expression?
        Overrides:
        equals in class AtomicSequenceConverter
        Parameters:
        other - the other operand; the result is false if this is not an Expression
        Returns:
        true if the other operand is an expression and if it can be determined that the two expressions are equivalent, in the sense that they will always return the same result.

      • displayOperator

        protected java.lang.String displayOperator​(Configuration config)
        Description copied from class: UnaryExpression
        Give a string representation of the operator for use in diagnostics
        Overrides:
        displayOperator in class AtomicSequenceConverter
        Parameters:
        config - the Saxon configuration
        Returns:
        the operator, as a string

      • getExpressionName

        public java.lang.String getExpressionName()
        Get a name identifying the kind of expression, in terms meaningful to a user.
        Overrides:
        getExpressionName in class AtomicSequenceConverter
        Returns:
        a name identifying the kind of expression, in terms meaningful to a user. The name will always be in the form of a lexical XML QName, and should match the name used in explain() output displaying the expression.

      • toShortString

        public java.lang.String toShortString()
        Description copied from class: Expression
        Produce a short string identifying the expression for use in error messages
        Overrides:
        toShortString in class UnaryExpression
        Returns:
        a short string, sufficient to identify the expression

      • export

        public void export​(ExpressionPresenter destination)
            throws XPathException
        Diagnostic print of expression structure. The abstract expression tree is written to the supplied output destination.
        Specified by:
        export in interface ExportAgent
        Overrides:
        export in class AtomicSequenceConverter
        Parameters:
        destination - the expression presenter used to display the structure
        Throws:
        XPathException - if the export fails, for example if an expression is found that won't work in the target environment.