Package net.sf.saxon.expr

Class AndExpression

    • Constructor Detail

      • AndExpression

        public AndExpression​(Expression p1,
                     Expression p2)
        Construct a boolean AND expression
        Parameters:
        p1 - the first operand
        p2 - the second operand

    • Method Detail

      • preEvaluate

        protected Expression preEvaluate()
        Description copied from class: BooleanExpression
        Evaluate the expression statically if either or both operands are literals. For example, (true() or X) returns true().
        Specified by:
        preEvaluate in class BooleanExpression
        Returns:
        a boolean literal if the expression can be evaluated now, or the original expression otherwise.

      • optimize

        public Expression optimize​(ExpressionVisitor visitor,
                           ContextItemStaticInfo contextInfo)
                    throws XPathException
        Perform optimisation of an expression and its subexpressions.

        This method is called after all references to functions and variables have been resolved to the declaration of the function or variable, and after all type checking has been done.

        Overrides:
        optimize in class BooleanExpression
        Parameters:
        visitor - an expression visitor
        contextInfo - the static type of "." at the point where this expression is invoked. The parameter is set to null if it is known statically that the context item will be undefined. If the type of the context item is not known statically, the argument is set to Type.ITEM_TYPE
        Returns:
        the original expression, rewritten if appropriate to optimize execution
        Throws:
        XPathException - if an error is discovered during this phase (typically a type error)

      • getCost

        public double getCost()
        Description copied from class: Expression
        Return the estimated cost of evaluating an expression. This is a very crude measure based on the syntactic form of the expression (we have no knowledge of data values). We take the cost of evaluating a simple scalar comparison or arithmetic expression as 1 (one), and we assume that a sequence has length 5. The resulting estimates may be used, for example, to reorder the predicates in a filter expression so cheaper predicates are evaluated first.
        Overrides:
        getCost in class Expression
        Returns:
        an estimate of the gross cost of evaluating the expression, including the cost of evaluating its operands.

      • copy

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

      • negate

        public Expression negate()
        Return the negation of this boolean expression, that is, an expression that returns true when this expression returns false, and vice versa
        Specified by:
        negate in interface Negatable
        Specified by:
        negate in class BooleanExpression
        Returns:
        the negation of this expression

      • tag

        protected java.lang.String tag()
        Get the element name used to identify this expression in exported expression format
        Overrides:
        tag in class BinaryExpression
        Returns:
        the element name used to identify this expression

      • distribute

        public static Expression distribute​(java.util.Collection<Expression> exprs)
        Generate an 'and' tree over a set of expressions
        Parameters:
        exprs - the expressions to be "and'ed" together
        Returns:
        the root of the new expression tree

      • getElaborator

        public Elaborator getElaborator()
        Make an elaborator for this expression
        Overrides:
        getElaborator in class Expression
        Returns:
        a suitable elaborator