Use {@link #getExprType()} to get the expression type. * * More information about expression are obtained by casting it * to its corresponding java type. Here the XPath expression type to Java type mapping table: *
*| Expression type | *Java type | *
| {@link #PATH_EXPR} | *{@link PathExpr} | *
| {@link #LOGICAL_EXPR} | *{@link OperatorExpr} | *
| {@link #CONDITIONAL_EXPR} | *{@link ConditionalExpr} | *
| {@link #ITERATION_EXPR} | *{@link ForAndQuantifiedExpr} | *
| {@link #EVERY_EXPR} | *{@link ForAndQuantifiedExpr} | *
| {@link #SOME_EXPR} | *{@link ForAndQuantifiedExpr} | *
| {@link #COMPARISON_EXPR} | *{@link OperatorExpr} | *
| {@link #ARITHMETIC_EXPR} | *{@link OperatorExpr} | *
| {@link #SEQUENCE_EXPR} | *{@link OperatorExpr} | *
| {@link #LITERAL_EXPR} | *{@link Literal} | *
| {@link #FUNCTION_CALL_EXPR} | *{@link FunctionCall} | *
| {@link #VARIABLE_REF_EXPR} | *{@link Variable} | *
| {@link #CONTEXT_ITEM_EXPR} | *{@link Expr} | *
| {@link #STEP_EXPR} | *{@link StepExpr} | *
| {@link #INSTANCE_OF_EXPR} | *{@link InstanceOfExpr} | *
| {@link #CAST_AS_EXPR} | *{@link CastableOrCastExpr} | *
| {@link #TREAT_AS_EXPR} | *{@link CastableOrCastExpr} | *
| {@link #CASTABLE_EXPR} | *{@link TreatExpr} | *
| {@link #SINGLE_TYPE_EXPR} | *{@link org.apache.xpath.datamodel.SingleType} | *
| {@link #SEQUENCE_TYPE_EXPR} | *{@link org.apache.xpath.datamodel.SequenceType} | *
For example the following code snippet may be used to get the items of * the expression e = (1, call(),(toto[/user], $author)):
*
* void printItem(Expr e)
* {
* if (e.getExprType() == Expr.SEQUENCE_EXPR)
* {
* OperatorExpr expr = (OperatorExpr) e;
* for (int i = 0; i %lt; expr.getOperandCount(); i ++ )
* {
* printItem(expr.getOperand(i));
* }
* } else
* {
* System.out.print(e.getString(true) + " ");
* }
* }
*
* Should produced the following result:
** 1 call() toto[/user] $author **
Applications should make no assumption about the expression type they * handle. They should always check out its type before casting it. * For example, operands of {@link PathExpr} may not be * {@link StepExpr}, in particular when step expression does not contain * predicates.
*XPath expressions are always fully expanded. For example, the expression * /a//b is expanded to fn:root(self::node())/descendant-or-self::node()/b. * The number of steps is then 3 (and not 2). *
** An {@link Expr} object may not be a valid XPath expression but only a fragment (or a part). * For example the {@link StepExpr} and {@link NodeTest} expression types are fragments * and therefore may not be interpretable by themself. However, since the validity * of an expression depends on the host language, the XPath API do not enforce this constraint. *
*Annotations can be placed on each expression fragment. Use {@link #getProperty(Object)} * and {@link #addProperty(Object, Object)} methods for that. *
* @see XPath 2.0 Specification * @author Lionel Villard * @version $Id$ */ public interface Expr { /** * The expression is a path expression */ static final short PATH_EXPR = 0; /** * The expression is a logical expression. * Represents 'or' and 'and' expressions. */ static final short LOGICAL_EXPR = 1; /** * The expression is a conditionnal expression (if) */ static final short CONDITIONAL_EXPR = 2; /** * The expression is an iteration expression (for) */ static final short ITERATION_EXPR = 3; /** * The expression is a quantified expression of type every */ static final short EVERY_EXPR = 4; /** * The expression is a quantified expression of type some */ static final short SOME_EXPR = 8; /** * The expression is a comparison expression type. * Includes value comparisons, general comparisons, node comparisons * and order comparisons. */ static final short COMPARISON_EXPR = 5; /** * The expression is an arithmetic expression. * Includes arithmetic operators for addition, subtraction, multiplication, division and modulus */ static final short ARITHMETIC_EXPR = 6; /** * The expression is a sequence. */ static final short SEQUENCE_EXPR = 7; /** * The expression is a validate expression */ static final short VALIDATE_EXPR = 10; /** * The expression is a literal expression */ static final short LITERAL_EXPR = 13; /** * The expression is a function call */ static final short FUNCTION_CALL_EXPR = 14; /** * The expression is a variable reference */ static final short VARIABLE_REF_EXPR = 15; /** * The expression is an instance of expression */ static final short INSTANCE_OF_EXPR = 18; /** * The expression is a cast as expression */ static final short CAST_AS_EXPR = 20; /** * The expression is a castable expression */ static final short CASTABLE_EXPR = 21; /** * The expression is a treat as expression */ static final short TREAT_AS_EXPR = 22; /** * The expression is the '.' expression */ static final short CONTEXT_ITEM_EXPR = 24; /** * The expression is a step */ static final short STEP_EXPR = 17; /** * The expression is a node test */ static final short NODE_TEST_EXPR = 11; /** * The expression is a single type */ static final short SINGLE_TYPE_EXPR = 25; /** * The expression is a sequence type */ static final short SEQUENCE_TYPE_EXPR = 11; /** * Gets expression type. * @return The type of this expression: one of the constants defined in this * interface */ short getExprType(); /** * Clone expression. The returned expression is a deep clone of this * expression. All information of this expression are cloned, expect * the parent attribute which is set tonull.
* @return A clone of this expression
*/
Expr cloneExpression();
//TODO: Expr cloneExpression(boolean deep);
/**
* Gets expression as a string (external form)
* @param abbreviate Gets the string as an abbreviate form or not
* @return The external form of this expression
*/
String getString(boolean abbreviate);
/**
* Visits expression. Walks through the expression hierarchy and
* invokes the corresponding {@link Visitor callbacks}.
* If the specified {@link Visitor} is an {@link EnhancedVisitor} then
* "leaving" events are fired.
* @return true to continue the visit or false to stop it.
*/
boolean visit(Visitor visitor);
/**
* Gets the parent expression.
* @return The parent expression or null if the expression is on the top level.
*/
Expr getParentExpr();
/**
* Normalizes expression.
* Performs the following normalization on this expression:
* null.
*/
void normalize();
/**
* Indicates whether an expression is "equal to" this one.
* The equality is defined in term of syntaxic equivalence: two
* expressions are equals if they have the same external representation
* (independently of abbreviated forms).
*/
public boolean equals(Object obj);
/**
* Add a key/value pair to the expression
* @param key
* @param value
*/
public void addProperty(Object key, Object value);
/**
* Retrieve the property from a given key
* @param key
* @return
*/
public Object getProperty(Object key);
/**
* Return the property associated with the given key.
* @param key
* @return
*/
public Object removeProperty(Object key);
/**
* Removes all properties.
*/
public void removeAllProperties();
}