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

- - ### Field Summary

    - ### Fields inherited from class net.sf.saxon.expr.BinaryExpression

      `operator`

    - ### Fields inherited from class net.sf.saxon.expr.Expression

      `EFFECTIVE_BOOLEAN_VALUE, EVALUATE_METHOD, ITEM_FEED_METHOD, ITERATE_METHOD, MAX_COST, MAX_SEQUENCE_LENGTH, MAX_STRING_LENGTH, PROCESS_METHOD, staticProperties, UNBOUNDED_LOWER, UNBOUNDED_UPPER, UPDATE_METHOD, WATCH_METHOD`

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `AndExpression​(Expression p1, Expression p2)` | Construct a boolean AND expression

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `Expression` | `copy​(RebindingMap rebindings)` | Copy an expression.
    `static Expression` | `distribute​(java.util.Collection<Expression> exprs)` | Generate an 'and' tree over a set of expressions
    `boolean` | `effectiveBooleanValue​(XPathContext c)` | Evaluate as a boolean.
    `double` | `getCost()` | Return the estimated cost of evaluating an expression.
    `Expression` | `negate()` | Return the negation of this boolean expression, that is, an expression that returns true when this expression returns false, and vice versa
    `Expression` | `optimize​(ExpressionVisitor visitor, ContextItemStaticInfo contextInfo)` | Perform optimisation of an expression and its subexpressions.
    `protected Expression` | `preEvaluate()` | Evaluate the expression statically if either or both operands are literals.
    `protected java.lang.String` | `tag()` | Get the element name used to identify this expression in exported expression format

    - ### Methods inherited from class net.sf.saxon.expr.BooleanExpression

      `computeCardinality, evaluateItem, forceToBoolean, getExpressionName, getItemType, getOperandRole, getStaticUType, isNegatable, listAndComponents, typeCheck`

    - ### Methods inherited from class net.sf.saxon.expr.BinaryExpression

      `computeHashCode, computeSpecialProperties, displayOperator, equals, explainExtraAttributes, export, getImplementationMethod, getLhs, getLhsExpression, getOperator, getRhs, getRhsExpression, isAssociative, isCommutative, isInverse, operands, setFlattened, setLhsExpression, setRhsExpression, toShortString, toString`

    - ### Methods inherited from class net.sf.saxon.expr.Expression

      `addToPathMap, adoptChildExpression, allowExtractingCommonSubexpressions, checkedOperands, checkForUpdatingSubexpressions, checkPermittedContents, computeDependencies, computeStaticProperties, dynamicError, evaluateAsString, evaluatePendingUpdates, explain, getCardinality, getConfiguration, getDependencies, getEvaluationMethod, getExtraProperty, getIntegerBounds, getInterpretedExpression, getIntrinsicDependencies, getLocalRetainedStaticContext, getLocation, getNetCost, getObjectName, getPackageData, getParentExpression, getProperties, getProperty, getRetainedStaticContext, getScopingExpression, getSlotsUsed, getSpecialProperties, getStaticBaseURI, getStaticBaseURIString, getStaticType, getStreamerName, getTracingTag, hasCompatibleStaticContext, hashCode, hasSpecialProperty, hasVariableBinding, identityHashCode, implementsStaticTypeCheck, isCallOn, isEqual, isIdentical, isInstruction, isLiftable, isMultiThreaded, isStaticPropertiesKnown, isSubtreeExpression, isUpdatingExpression, isVacuousExpression, iterate, markTailFunctionCalls, operandList, operandSparseList, optimizeChildren, prepareForStreaming, process, resetLocalStaticProperties, restoreParentPointers, setEvaluationMethod, setExtraProperty, setFiltered, setLocation, setParentExpression, setRetainedStaticContext, setRetainedStaticContextLocally, setRetainedStaticContextThoroughly, setStaticProperty, simplify, simplifyChildren, staticTypeCheck, suppressValidation, toPattern, typeCheckChildren, typeError, unordered, verifyParentPointers`

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

    - ### Methods inherited from interface net.sf.saxon.trace.Traceable

      `gatherProperties`

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

    - #### 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​(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