Package net.sf.saxon.expr

Class AndExpression

java.lang.Object
net.sf.saxon.expr.Expression
net.sf.saxon.expr.BinaryExpression
net.sf.saxon.expr.BooleanExpression
net.sf.saxon.expr.AndExpression
All Implemented Interfaces:
ExportAgent, Locatable, Negatable, IdentityComparable, Traceable
public class AndExpression extends BooleanExpression

  • Constructor Details

    • AndExpression

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

  • Method Details

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

    • effectiveBooleanValue

      public boolean effectiveBooleanValue(XPathContext c) throws XPathException
      Evaluate as a boolean.
      Specified by:
      effectiveBooleanValue in class BooleanExpression
      Parameters:
      c - The context in which the expression is to be evaluated
      Returns:
      the effective boolean value
      Throws:
      XPathException - if any dynamic error occurs evaluating the expression

    • distribute

      public static Expression distribute(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