Uses of Interface
jd.xml.xpath.expr.Expression

Packages that use Expression
jd.xml.xpath.expr Contains the base XPath expression classes. 
jd.xml.xpath.expr.compare Contains classes for the =, !=, >, >=, <, <= operators. 
jd.xml.xpath.expr.function Contains the XPath functions. 
jd.xml.xpath.expr.misc Contains classes representing various XPath expressions. 
jd.xml.xpath.expr.operator Contains classes representing various XPath operators. 
jd.xml.xpath.expr.path   
jd.xml.xpath.expr.visitor   
jd.xml.xpath.parser Contains the XPath expression parser. 
jd.xml.xpath.tool Contains utility classes to evaluate XPath expressions. 
jd.xml.xslt Contains a XSLT Version 1.1 implementation. 
jd.xml.xslt.expr Contains the XPath functions and expressions defined by XSLT. 
jd.xml.xslt.extension Contains support for extension functions defined by the XSLT script element. 
jd.xml.xslt.format Contains helper classes for XSLT format and sort tasks. 
jd.xml.xslt.parser Contains parser classes for stylesheets, stylesheet templates elements and patterns. 
jd.xml.xslt.pattern Contains classes for XSLT template patterns. 
jd.xml.xslt.template Contains classes representing the various XSLT template elements and instructions. 
jd.xml.xslt.trace   
 

Uses of Expression in jd.xml.xpath.expr
 

Classes in jd.xml.xpath.expr that implement Expression
 class BooleanExpression
          BooleanExpression is an expression which evaluates to a boolean.
 class ExpressionImpl
          ExpressionImpl provides a reasonable default implementation of many expression methods.
 class NodeSetExpression
          NodeSetExpression is an expression which evaluates to a NodeSet.
 class NumericExpression
          NumericExpression is an expression which evaluates to a number.
 class StringExpression
          StringExpression is an expression which evaluates to a string.
 class VariableExpression
          VariableExpression is an expression which can evaluate to objects with different types.
 

Methods in jd.xml.xpath.expr with parameters of type Expression
static int NodeSetExpression.getMinResultSize(Expression expr)
           
static int NodeSetExpression.getMaxResultSize(Expression expr)
           
 void ExpressionVisitor.and(Expression expr, Expression lhs, Expression rhs)
           
 void ExpressionVisitor.add(Expression expr, Expression lhs, Expression rhs)
           
 void ExpressionVisitor.compare(Expression expr, Expression lhs, Equality equality, Expression rhs)
          Called by a equality expression.
 void ExpressionVisitor.compare(Expression expr, Expression lhs, Relation relation, Expression rhs)
           
 void ExpressionVisitor.composedPath(Expression expr, Expression lhs, Expression rhs)
           
 void ExpressionVisitor.composedPath(Expression expr, Expression[] steps)
           
 void ExpressionVisitor.constant(Expression expr, XObject object)
           
 void ExpressionVisitor.divide(Expression expr, Expression lhs, Expression rhs)
           
 void ExpressionVisitor.function(Expression expr, String name, Expression[] args)
           
 void ExpressionVisitor.invalid(Expression expr, String message, String error)
           
 void ExpressionVisitor.locationStep(Expression expr, Axis axis, NodeTest nodeTest)
           
 void ExpressionVisitor.locationStep(Expression expr, Axis axis, NodeTest nodeTest, Expression predicate, boolean useForwardProximity, boolean isUniqueFilter)
           
 void ExpressionVisitor.modulo(Expression expr, Expression lhs, Expression rhs)
           
 void ExpressionVisitor.multiply(Expression expr, Expression lhs, Expression rhs)
           
 void ExpressionVisitor.negate(Expression expr, Expression innerExpr)
           
 void ExpressionVisitor.or(Expression expr, Expression lhs, Expression rhs)
           
 void ExpressionVisitor.parenthesis(Expression expr, Expression innerExpr)
           
 void ExpressionVisitor.predicate(Expression expr, Expression nodeSetExpr, Expression predicate, boolean useForwardProximity)
           
 void ExpressionVisitor.root(Expression expr)
           
 void ExpressionVisitor.subtract(Expression expr, Expression lhs, Expression rhs)
           
 void ExpressionVisitor.union(Expression expr, Expression lhs, Expression rhs)
           
 void ExpressionVisitor.variableReference(Expression expr, VariableName name)
           
 

Uses of Expression in jd.xml.xpath.expr.compare
 

Classes in jd.xml.xpath.expr.compare that implement Expression
 class Equals
          A base class for equality comparision.
 class EqualsBooleans
          A Equals implementation which compares two boolean values.
 class EqualsNumbers
          A Equals implementation which compares two number values.
 class EqualsObjectNumber
          A Equals implementation which compares a object and a number.
 class EqualsObjects
          A Equals implementation which compares two XObjects.
 class EqualsObjectString
          A Equals implementation which compares a variable value and a string.
 class EqualsSetSimple
          A Equals implementation which compares a set and a simple value.
 class EqualsStrings
          A Equals implementation which compares two string values.
 class Relate
          A base class for relational comparisions.
 class RelateNumbers
          A Relate implementation for number expressiona.
 class RelateObjectNumber
          A Relate implementation which compares a variable or node-set with a number value.
 class RelateObjects
          A Relate implementation which compares a variable or node-set with a number value.
 

Methods in jd.xml.xpath.expr.compare that return Expression
static Expression CompareFactory.createRelate(Expression expr1, Relation relation, Expression expr2)
           
static Expression CompareFactory.createEquals(Expression expr1, Equality equality, Expression expr2)
           
 

Methods in jd.xml.xpath.expr.compare with parameters of type Expression
static Expression CompareFactory.createRelate(Expression expr1, Relation relation, Expression expr2)
           
static Expression CompareFactory.createEquals(Expression expr1, Equality equality, Expression expr2)
           
 

Constructors in jd.xml.xpath.expr.compare with parameters of type Expression
RelateObjects(Expression lhs, Relation relation, Expression rhs)
           
RelateObjectNumber(Expression lhs, Relation relation, Expression rhs)
           
RelateNumbers(Expression lhs, Relation relation, Expression rhs)
           
Relate(Expression lhs, Relation relation, Expression rhs)
           
EqualsStrings(Expression lhs, Equality equality, Expression rhs)
           
EqualsSetSimple(Expression lhs, Equality equality, Expression rhs)
           
EqualsObjectString(Expression lhs, Equality equality, Expression rhs)
           
EqualsObjects(Expression lhs, Equality equality, Expression rhs)
           
EqualsObjectNumber(Expression lhs, Equality equality, Expression rhs)
           
EqualsNumbers(Expression lhs, Equality equality, Expression rhs)
           
EqualsBooleans(Expression lhs, Equality equality, Expression rhs)
           
Equals(Expression lhs, Equality equality, Expression rhs)
           
 

Uses of Expression in jd.xml.xpath.expr.function
 

Subinterfaces of Expression in jd.xml.xpath.expr.function
 interface Function
          Function represents a XPath function.
 

Classes in jd.xml.xpath.expr.function that implement Expression
 class Average
          Average represents the optimized xpath expression "sum(node-set x) div count(node-set x)".
 class BooleanFunction
          A base class for all functions which evaluate to a boolean.
 class Ceiling
          Ceiling represents the xpath core function "number ceiling(number)".
 class Concat
          Concat represents the xpath core function "string concat(string, string, string *)".
 class Contains
          Contains represents the xpath core function "contains(string, string)".
 class Count
          Count represents the xpath core function "number count(nodeset)".
 class False
          False represents the xpath core function "boolean false()".
 class Floor
          Floor represents the xpath core function "number floor(number)".
 class Id
          Id represents the xpath core function "node-set id(object)".
 class Lang
          Lang represents the xpath core function "boolean lang(string)".
 class Last
          Last represents the xpath core function "number last()".
 class LocalName
          LocalName represents the xpath core function "local-name(node-set?)".
 class Name
          Name represents the xpath core function "string name(node-set?)".
 class NamespaceUri
          NameSpaceUri represents the xpath core function "string namespace-uri(node-set?)".
 class NodeFunction
          NodeFunction is a base class for functions which use the first node of the node-set argument or the context node to calculate their string result.
 class NodeSetFunction
          A base class for all functions which evaluates to a node-set.
 class NormalizeSpace
          NormalizeSpace represents the xpath core function "string normalize-space(string?)".
 class Not
          Not represents the xpath core function "boolean not(boolean)".
 class NumericFunction
          A base class for all functions which evaluate to a number.
 class Position
          Position represents the xpath core function "number position()".
 class Round
          Round represents the xpath core function "number round(number)".
 class StartsWith
          StartsWith represents the xpath core function "boolean starts-with(string, string)".
 class StringFunction
          A base class for all functions which evaluate to a String.
 class StringLength
          StringLength represents the xpath core function "number string-length(string?)".
 class Substring
          Substring represents the xpath core function "string substring(string, number, number?)".
 class SubstringAfter
          SubstringAfter represents the xpath core function "string substring-after(string, string)".
 class SubstringBefore
          SubstringBefore represents the xpath core function "string substring-before(string, string)".
 class Sum
          Sum represents the xpath core function "number sum(node-set)".
 class ToBoolean
          ToBoolean represents the xpath core function "boolean boolean(object)".
 class ToNumber
          ToNumber represents the xpath core function "number number(object?)".
 class ToString
          ToString represents the xpath core function "string string(object?)".
 class Translate
          Translate represents the xpath core function "string translate(string, string, string)".
 class True
          True represents the xpath core function "boolean true()".
 class VariableFunction
          A base class for all functions which evaluate to objects with different types.
 

Fields in jd.xml.xpath.expr.function declared as Expression
protected  Expression[] VariableFunction.arguments_
           
protected  Expression[] StringFunction.arguments_
           
protected  Expression[] NumericFunction.arguments_
           
protected  Expression[] NodeSetFunction.arguments_
           
static Expression[] Function.NULL_ARGUMENTS
           
protected  Expression[] BooleanFunction.arguments_
           
 

Methods in jd.xml.xpath.expr.function that return Expression
 Expression VariableFunction.getArgument(int i)
           
 Expression StringFunction.getArgument(int i)
           
 Expression NumericFunction.getArgument(int i)
           
 Expression NodeSetFunction.getArgument(int i)
           
 Expression[] FunctionType.normArguments(Expression[] arguments)
          Check and norm the arguments.
 Expression Function.getArgument(int i)
          Return the actual argument for the given index.
 Expression BooleanFunction.getArgument(int i)
           
 

Methods in jd.xml.xpath.expr.function with parameters of type Expression
 void VariableFunction.setArguments(Expression[] arguments)
           
 void StringFunction.setArguments(Expression[] arguments)
           
 void NumericFunction.setArguments(Expression[] arguments)
           
 void NodeSetFunction.setArguments(Expression[] arguments)
           
 int NodeFunctionType.getContextDependencies(Expression[] arguments)
          Return a bitfield indicating the dependencies of the function arguments.
 Expression[] FunctionType.normArguments(Expression[] arguments)
          Check and norm the arguments.
 int FunctionType.getContextDependencies(Expression[] arguments)
          Return a bitfield indicating the dependencies of the function arguments.
 boolean FunctionType.isFunctionInstance(Expression expr)
          Return if the given Expression is an instance of the function represented by this type.
 void Function.setArguments(Expression[] arguments)
          Set the function arguments.
 void BooleanFunction.setArguments(Expression[] arguments)
           
 

Uses of Expression in jd.xml.xpath.expr.misc
 

Classes in jd.xml.xpath.expr.misc that implement Expression
 class Constant
          Constant represents an expression that evaluates to a constant XObject.
 class Negate
          Negate represents the negate expression.
 class ParenthesisExpression
          ParenthesisExpression represents the Expression of the production rule '(' Expr ')'.
 class ProxyExpression
          ProxyExpression wraps another expression.
 class VariableReference
          VariableReference is an expression that evaluates to the value of a variable.
 

Fields in jd.xml.xpath.expr.misc declared as Expression
protected  Expression ProxyExpression.expr_
           
 

Methods in jd.xml.xpath.expr.misc that return Expression
 Expression ProxyExpression.getExpression()
           
 

Constructors in jd.xml.xpath.expr.misc with parameters of type Expression
ProxyExpression(Expression expr)
           
ParenthesisExpression(Expression expr)
           
Negate(Expression expr)
           
 

Uses of Expression in jd.xml.xpath.expr.operator
 

Subinterfaces of Expression in jd.xml.xpath.expr.operator
 interface Operator
          A common interface for operator expressions.
 

Classes in jd.xml.xpath.expr.operator that implement Expression
 class Add
          Add represents the '+' expression.
 class And
          And represents the 'and' expression.
 class BooleanOperator
          BooleanOperator is a base class for operators that operate on booleans.
 class Divide
          Add represents the 'div' expression.
 class Modulo
          Mod represents the 'mod' expression.
 class Multiply
          Multiply represents the '*' expression.
 class NodeSetOperator
          NodeSetOperator is a base class for operations that take two node-set expression arguments and return a node-set.
 class NumericOperator
          NumericOperator is a base class for numeric operations.
 class Or
          Or represents the 'or' expression.
 class Subtract
          Subtract represents the '-' expression.
 class Union
          Union represents the '|' expression.
 

Fields in jd.xml.xpath.expr.operator declared as Expression
protected  Expression NumericOperator.lhs_
           
protected  Expression NumericOperator.rhs_
           
protected  Expression NodeSetOperator.lhs_
           
protected  Expression NodeSetOperator.rhs_
           
protected  Expression BooleanOperator.lhs_
           
protected  Expression BooleanOperator.rhs_
           
 

Methods in jd.xml.xpath.expr.operator that return Expression
 Expression NodeSetOperator.getLhs()
          Return the "left hand side" expression.
 Expression NodeSetOperator.getRhs()
          Return the "right hand side" expression.
 

Constructors in jd.xml.xpath.expr.operator with parameters of type Expression
Union(Expression lhs, Expression rhs)
           
Subtract(Expression lhs, Expression rhs)
           
Or(Expression lhs, Expression rhs)
           
NumericOperator(Expression lhs, Expression rhs)
          Create a NumericExpression.
NodeSetOperator(Expression lhs, Expression rhs)
           
Multiply(Expression lhs, Expression rhs)
           
Modulo(Expression lhs, Expression rhs)
           
Divide(Expression lhs, Expression rhs)
           
BooleanOperator(Expression lhs, Expression rhs)
          Create a BooleanOperator.
And(Expression lhs, Expression rhs)
          Create a And expression.
Add(Expression lhs, Expression rhs)
           
 

Uses of Expression in jd.xml.xpath.expr.path
 

Classes in jd.xml.xpath.expr.path that implement Expression
 class ComposedPath
          ComposedPath is an expression for the production rule "FilterExpr '/' RelativeLocationPath".
 class FilteredLocationStep
          A FilteredLocationStep is a LocationStep with a simple filter predicate that uses axis iterators for evaluation and is therefore faster than a heavyweight PredicateExpression.
 class LocationStep
          An expression class to represent XPath location steps with and without predicate filters.
 class LocationStepChain
          A LocationStepChain is a sequence of single location steps, chained together by the '/' operator.
 class PredicateExpression
          PredicateExpression represents a predicate that filters a nodeset resulting from another expression.
 class RootPath
          The RootPath represents the path expression "/".
 class SimpleLocationStep
          An LocationStep without predicate filters-
 

Methods in jd.xml.xpath.expr.path with parameters of type Expression
static LocationStepChain LocationStepChain.create(Expression lhs, LocationStep rhs)
           
static FilteredLocationStep FilteredLocationStep.create(SimpleLocationStep step, Expression filter)
          Create a FilteredLocationStep if possible
 

Constructors in jd.xml.xpath.expr.path with parameters of type Expression
PredicateExpression(Expression nodeSetExpr, Expression predicateExpr, boolean useForwardProximity)
          Create a PredicateExpression.
ComposedPath(Expression lhs, Expression rhs)
          Create a ComposedPath.
 

Uses of Expression in jd.xml.xpath.expr.visitor
 

Methods in jd.xml.xpath.expr.visitor that return Expression
 Expression ExprSimplifier.simplify(Expression expr)
           
 

Methods in jd.xml.xpath.expr.visitor with parameters of type Expression
 String ExprWriter.print(Expression expr)
           
 void ExprWriter.add(Expression expr, Expression lhs, Expression rhs)
           
 void ExprWriter.and(Expression expr, Expression lhs, Expression rhs)
           
 void ExprWriter.compare(Expression expr, Expression lhs, Equality equality, Expression rhs)
           
 void ExprWriter.compare(Expression expr, Expression lhs, Relation relation, Expression rhs)
           
 void ExprWriter.composedPath(Expression expr, Expression lhs, Expression rhs)
           
 void ExprWriter.composedPath(Expression expr, Expression[] steps)
           
 void ExprWriter.constant(Expression expr, XObject object)
           
 void ExprWriter.divide(Expression expr, Expression lhs, Expression rhs)
           
 void ExprWriter.function(Expression expr, String name, Expression[] args)
           
 void ExprWriter.invalid(Expression expr, String message, String error)
           
 void ExprWriter.locationStep(Expression expr, Axis axis, NodeTest nodeTest)
           
 void ExprWriter.locationStep(Expression expr, Axis axis, NodeTest nodeTest, Expression predicate, boolean useForwardProximity, boolean isUniqueFilter)
           
 void ExprWriter.modulo(Expression expr, Expression lhs, Expression rhs)
           
 void ExprWriter.multiply(Expression expr, Expression lhs, Expression rhs)
           
 void ExprWriter.negate(Expression expr, Expression innerExpr)
           
 void ExprWriter.or(Expression expr, Expression lhs, Expression rhs)
           
 void ExprWriter.parenthesis(Expression expr, Expression innerExpr)
           
 void ExprWriter.predicate(Expression expr, Expression nodeSetExpr, Expression predicate, boolean useForwardProximity)
           
 void ExprWriter.root(Expression expr)
           
 void ExprWriter.subtract(Expression expr, Expression lhs, Expression rhs)
           
 void ExprWriter.union(Expression expr, Expression lhs, Expression rhs)
           
 void ExprWriter.variableReference(Expression expr, VariableName name)
           
 void ExprVisitorImpl.and(Expression expr, Expression lhs, Expression rhs)
           
 void ExprVisitorImpl.add(Expression expr, Expression lhs, Expression rhs)
           
 void ExprVisitorImpl.compare(Expression expr, Expression lhs, Equality equality, Expression rhs)
           
 void ExprVisitorImpl.compare(Expression expr, Expression lhs, Relation relation, Expression rhs)
           
 void ExprVisitorImpl.composedPath(Expression expr, Expression lhs, Expression rhs)
           
 void ExprVisitorImpl.composedPath(Expression expr, Expression[] steps)
           
 void ExprVisitorImpl.constant(Expression expr, XObject object)
           
 void ExprVisitorImpl.divide(Expression expr, Expression lhs, Expression rhs)
           
 void ExprVisitorImpl.function(Expression expr, String name, Expression[] args)
           
 void ExprVisitorImpl.invalid(Expression expr, String message, String error)
           
 void ExprVisitorImpl.locationStep(Expression expr, Axis axis, NodeTest nodeTest)
           
 void ExprVisitorImpl.locationStep(Expression expr, Axis axis, NodeTest nodeTest, Expression predicate, boolean useForwardProximity, boolean isUniqueFilter)
           
 void ExprVisitorImpl.modulo(Expression expr, Expression lhs, Expression rhs)
           
 void ExprVisitorImpl.multiply(Expression expr, Expression lhs, Expression rhs)
           
 void ExprVisitorImpl.negate(Expression expr, Expression innerExpr)
           
 void ExprVisitorImpl.or(Expression expr, Expression lhs, Expression rhs)
           
 void ExprVisitorImpl.parenthesis(Expression expr, Expression innerExpr)
           
 void ExprVisitorImpl.predicate(Expression expr, Expression nodeSetExpr, Expression predicate, boolean useForwardProximity)
           
 void ExprVisitorImpl.root(Expression expr)
           
 void ExprVisitorImpl.subtract(Expression expr, Expression lhs, Expression rhs)
           
 void ExprVisitorImpl.union(Expression expr, Expression lhs, Expression rhs)
           
 void ExprVisitorImpl.variableReference(Expression expr, VariableName name)
           
 void ExprTreeWriter.print(Expression expr)
           
 void ExprTreeWriter.add(Expression expr, Expression lhs, Expression rhs)
           
 void ExprTreeWriter.and(Expression expr, Expression lhs, Expression rhs)
           
 void ExprTreeWriter.compare(Expression expr, Expression lhs, Equality equality, Expression rhs)
           
 void ExprTreeWriter.compare(Expression expr, Expression lhs, Relation relation, Expression rhs)
           
 void ExprTreeWriter.composedPath(Expression expr, Expression lhs, Expression rhs)
           
 void ExprTreeWriter.composedPath(Expression expr, Expression[] steps)
           
 void ExprTreeWriter.constant(Expression expr, XObject object)
           
 void ExprTreeWriter.divide(Expression expr, Expression lhs, Expression rhs)
           
 void ExprTreeWriter.function(Expression expr, String name, Expression[] args)
           
 void ExprTreeWriter.invalid(Expression expr, String message, String error)
           
 void ExprTreeWriter.locationStep(Expression expr, Axis axis, NodeTest nodeTest)
           
 void ExprTreeWriter.locationStep(Expression expr, Axis axis, NodeTest nodeTest, Expression predicate, boolean useForwardProximity, boolean isUniqueFilter)
           
 void ExprTreeWriter.modulo(Expression expr, Expression lhs, Expression rhs)
           
 void ExprTreeWriter.multiply(Expression expr, Expression lhs, Expression rhs)
           
 void ExprTreeWriter.negate(Expression expr, Expression innerExpr)
           
 void ExprTreeWriter.or(Expression expr, Expression lhs, Expression rhs)
           
 void ExprTreeWriter.parenthesis(Expression expr, Expression innerExpr)
           
 void ExprTreeWriter.predicate(Expression expr, Expression nodeSetExpr, Expression predicateExpr, boolean useForwardProximity)
           
 void ExprTreeWriter.root(Expression expr)
           
 void ExprTreeWriter.subtract(Expression expr, Expression lhs, Expression rhs)
           
 void ExprTreeWriter.union(Expression expr, Expression lhs, Expression rhs)
           
 void ExprTreeWriter.variableReference(Expression expr, VariableName name)
           
 Expression ExprSimplifier.simplify(Expression expr)
           
 void ExprSimplifier.add(Expression expr, Expression lhs, Expression rhs)
           
 void ExprSimplifier.and(Expression expr, Expression lhs, Expression rhs)
           
 void ExprSimplifier.compare(Expression expr, Expression lhs, Equality equality, Expression rhs)
           
 void ExprSimplifier.compare(Expression expr, Expression lhs, Relation relation, Expression rhs)
           
 void ExprSimplifier.composedPath(Expression expr, Expression lhs, Expression rhs)
           
 void ExprSimplifier.composedPath(Expression expr, Expression[] steps)
           
 void ExprSimplifier.constant(Expression expr, XObject object)
           
 void ExprSimplifier.divide(Expression expr, Expression lhs, Expression rhs)
           
 void ExprSimplifier.function(Expression expr, String name, Expression[] args)
           
 void ExprSimplifier.invalid(Expression expr, String message, String error)
           
 void ExprSimplifier.locationStep(Expression expr, Axis axis, NodeTest nodeTest)
           
 void ExprSimplifier.locationStep(Expression expr, Axis axis, NodeTest nodeTest, Expression predicate, boolean useForwardProximity, boolean isUniqueFilter)
           
 void ExprSimplifier.modulo(Expression expr, Expression lhs, Expression rhs)
           
 void ExprSimplifier.multiply(Expression expr, Expression lhs, Expression rhs)
           
 void ExprSimplifier.negate(Expression expr, Expression innerExpr)
           
 void ExprSimplifier.or(Expression expr, Expression lhs, Expression rhs)
           
 void ExprSimplifier.parenthesis(Expression expr, Expression innerExpr)
           
 void ExprSimplifier.predicate(Expression expr, Expression nodeSetExpr, Expression predicate, boolean useForwardProximity)
           
 void ExprSimplifier.root(Expression expr)
           
 void ExprSimplifier.subtract(Expression expr, Expression lhs, Expression rhs)
           
 void ExprSimplifier.union(Expression expr, Expression lhs, Expression rhs)
           
 void ExprSimplifier.variableReference(Expression expr, VariableName name)
           
 void ExprScreener.add(Expression expr, Expression lhs, Expression rhs)
           
 void ExprScreener.and(Expression expr, Expression lhs, Expression rhs)
           
 void ExprScreener.compare(Expression expr, Expression lhs, Equality equality, Expression rhs)
           
 void ExprScreener.compare(Expression expr, Expression lhs, Relation relation, Expression rhs)
           
 void ExprScreener.composedPath(Expression expr, Expression lhs, Expression rhs)
           
 void ExprScreener.composedPath(Expression expr, Expression[] steps)
           
 void ExprScreener.divide(Expression expr, Expression lhs, Expression rhs)
           
 void ExprScreener.function(Expression expr, String name, Expression[] args)
           
 void ExprScreener.locationStep(Expression expr, Axis axis, NodeTest nodeTest, Expression predicate, boolean useForwardProximity, boolean isUniqueFilter)
           
 void ExprScreener.modulo(Expression expr, Expression lhs, Expression rhs)
           
 void ExprScreener.multiply(Expression expr, Expression lhs, Expression rhs)
           
 void ExprScreener.negate(Expression expr, Expression innerExpr)
           
 void ExprScreener.or(Expression expr, Expression lhs, Expression rhs)
           
 void ExprScreener.parenthesis(Expression expr, Expression innerExpr)
           
 void ExprScreener.predicate(Expression expr, Expression nodeSetExpr, Expression predicate, boolean useForwardProximity)
           
 void ExprScreener.subtract(Expression expr, Expression lhs, Expression rhs)
           
 void ExprScreener.union(Expression expr, Expression lhs, Expression rhs)
           
 int ExprPrecedence.getPrecedence(Expression expr)
           
 boolean ExprPrecedence.isComplexNodeSetExpr(Expression expr)
           
 void ExprPrecedence.add(Expression expr, Expression lhs, Expression rhs)
           
 void ExprPrecedence.and(Expression expr, Expression lhs, Expression rhs)
           
 void ExprPrecedence.compare(Expression expr, Expression lhs, Equality equality, Expression rhs)
           
 void ExprPrecedence.compare(Expression expr, Expression lhs, Relation relation, Expression rhs)
           
 void ExprPrecedence.composedPath(Expression expr, Expression lhs, Expression rhs)
           
 void ExprPrecedence.composedPath(Expression expr, Expression[] steps)
           
 void ExprPrecedence.divide(Expression expr, Expression lhs, Expression rhs)
           
 void ExprPrecedence.modulo(Expression expr, Expression lhs, Expression rhs)
           
 void ExprPrecedence.multiply(Expression expr, Expression lhs, Expression rhs)
           
 void ExprPrecedence.or(Expression expr, Expression lhs, Expression rhs)
           
 void ExprPrecedence.subtract(Expression expr, Expression lhs, Expression rhs)
           
 void ExprPrecedence.union(Expression expr, Expression lhs, Expression rhs)
           
 

Uses of Expression in jd.xml.xpath.parser
 

Methods in jd.xml.xpath.parser that return Expression
 Expression ExpressionParser.parseExpression(String expression)
           
 Expression ExpressionParser.parseExpression(Scanner scanner)
          Parse the production rule: Expr ::= OrExpr
protected  Expression ExpressionParser.createFunction(Scanner scanner, String functionName, Expression[] arguments)
          Create a function call expression for a function with the given name and arguments.
 

Methods in jd.xml.xpath.parser with parameters of type Expression
protected  Expression ExpressionParser.createFunction(Scanner scanner, String functionName, Expression[] arguments)
          Create a function call expression for a function with the given name and arguments.
 

Uses of Expression in jd.xml.xpath.tool
 

Methods in jd.xml.xpath.tool that return Expression
 Expression XPath.getExpression()
          Return the parsed XPath expression.
 

Constructors in jd.xml.xpath.tool with parameters of type Expression
XPath(Expression expr)
          Create a XPath object for the given Expression.
 

Uses of Expression in jd.xml.xslt
 

Methods in jd.xml.xslt that return Expression
 Expression AttributeValue.getExpression()
           
 

Methods in jd.xml.xslt with parameters of type Expression
 Function XsltContext.getExtensionFunction(String namespaceUri, String functionName, Expression[] arguments)
          Return an extension function.
static AttributeValue AttributeValue.create(AttributeValue first, String s, Expression expr)
           
 

Constructors in jd.xml.xslt with parameters of type Expression
AttributeValue(String string, Expression expression)
          Create a new AttributeValue.
 

Uses of Expression in jd.xml.xslt.expr
 

Subinterfaces of Expression in jd.xml.xslt.expr
 interface XsltFunction
          A interface for XSLT functions which need to be initialized by the static expression context.
 

Classes in jd.xml.xslt.expr that implement Expression
 class Available
          Available is a base class for ElementAvailable and FunctionAvailable
 class Current
          Current represents the xslt function "node-set current()".
 class DocumentFunction
          Document represents the xslt function "node-set document(object, node-set?)".
 class ElementAvailable
          ElementAvailable represents the xslt function "boolean element-available(string) ".
 class FormatNumber
          FormatNumber represents the xslt function "string format-number(number, string, string?)".
 class FunctionAvailable
          FunctionAvailable represents the xslt function "boolean function-available(string)".
 class GenerateId
          GenerateId represents the xslt function "string generate-id(node-set?)".
 class InvalidExpression
          An expression class for invalid expressions encountered in forward compatible processing mode.
 class InvalidFunction
          InvalidFunction is a placeholder for invalid function calls which are encountered in forward compatible processing mode.
 class KeyFunction
          Document represents the xslt function "node-set key(string, object)".
 class SystemProperty
          SystemProperty represents the xslt function "string system-property(string)".
 class TextContentExpression
          A NodeSet constructed by the template of a variable binding element.
 class UnparsedEntityUri
          UnparsedEntityUri represents the xslt function "string unparsed-entity-uri(string)".
 

Uses of Expression in jd.xml.xslt.extension
 

Classes in jd.xml.xslt.extension that implement Expression
 class ExtensionFunction
           
 class ExtensionFunctionCall
          ExtensionFunctionCall is a function call to an extension function, i.e.
 class JavaFunction
          A XPath function that is evaluated by calling a java method.
 class ScriptFunction
          A Xpath function that is evaluated by calling a script function.
 

Methods in jd.xml.xslt.extension with parameters of type Expression
 Function ScriptExtensionHandler.getFunction(XsltContext context, String functionName, Expression[] arguments)
          Return a extension function for the given name.
 Function JavaExtensionHandler.getFunction(XsltContext context, String methodName, Expression[] arguments)
          Return an extension function for the given name.
abstract  Function ExtensionHandler.getFunction(XsltContext context, String name, Expression[] arguments)
          Return an extension function for the given name.
 

Constructors in jd.xml.xslt.extension with parameters of type Expression
JavaFunction(Expression object, Method method, boolean hasJdContext, boolean hasW3cContext)
           
ExtensionFunctionCall(String functionName, String namespaceUri, Expression[] arguments)
          Create a new ExtensionFunctionCall.
 

Uses of Expression in jd.xml.xslt.format
 

Methods in jd.xml.xslt.format that return Expression
 Expression ValueNumbering.getExpression()
           
 Expression Sort.getSelect()
           
 

Constructors in jd.xml.xslt.format with parameters of type Expression
ValueNumbering(Expression expr)
           
Sort(Expression select, AttributeValue lang, AttributeValue dataType, AttributeValue order, AttributeValue caseOrder)
           
 

Uses of Expression in jd.xml.xslt.parser
 

Methods in jd.xml.xslt.parser that return Expression
 Expression TextContentBuilder.getTextExpression()
          Return the text expression
 Expression PatternParser.parseExpression(String source)
           
protected  Expression PatternParser.createFunction(Scanner scanner, String functionName, Expression[] arguments)
           
 Expression ParseListener.expressionParsed(XsltParseContext context, Expression expression, String source)
           
 Expression AttributeIterator.getExpression()
          Return the value of the current attribute as a parsed expression.
 

Methods in jd.xml.xslt.parser with parameters of type Expression
 void XsltParseContext.addKey(String name, Pattern match, Expression use)
           
 void TextContentBuilder.applyTemplates(TemplateRuleList rules, Expression select, Sort sort, Variable[] params)
           
 void TextContentBuilder.condition(Expression test, Template content)
           
 void TextContentBuilder.copyOf(Expression select)
           
 void TextContentBuilder.forEach(Expression select, Sort sort, Template content)
           
 void TextContentBuilder.valueOf(Expression expr, boolean disableOutputEscaping)
           
protected  Expression PatternParser.createFunction(Scanner scanner, String functionName, Expression[] arguments)
           
 Expression ParseListener.expressionParsed(XsltParseContext context, Expression expression, String source)
           
 

Uses of Expression in jd.xml.xslt.pattern
 

Methods in jd.xml.xslt.pattern that return Expression
 Expression Key.getUse()
           
 

Methods in jd.xml.xslt.pattern with parameters of type Expression
 void PatternWriter.stepPattern(Pattern pattern, int principalNodeType, NodeTest nodeTest, Expression[] predicates, int lastSizePredicate, int lastNumericPredicate)
           
 void PatternVisitor.stepPattern(Pattern pattern, int principcalNodeType, NodeTest nodeTest, Expression[] predicates, int lastSizePredicate, int lastNumericPredicate)
           
 void PatternClassifier.stepPattern(Pattern pattern, int principalType, NodeTest nodeTest, Expression[] predicates, int lastSizePredicate, int lastNumericPredicate)
           
 

Constructors in jd.xml.xslt.pattern with parameters of type Expression
Key(Pattern pattern, Expression use, int index)
          Create a Key.
FilteredStepPattern(boolean useChildAxis, NodeTest nodeTest, Expression[] predicates)
           
 

Uses of Expression in jd.xml.xslt.template
 

Methods in jd.xml.xslt.template that return Expression
 Expression Variable.getExpression()
          Return the expression or null.
 

Methods in jd.xml.xslt.template with parameters of type Expression
 void TemplateVisitor.applyTemplates(TemplateRuleList rules, Expression select, Sort sort, Variable[] params)
           
 void TemplateVisitor.condition(Expression test, Template content)
           
 void TemplateVisitor.copyOf(Expression select)
           
 void TemplateVisitor.forEach(Expression select, Sort sort, Template content)
           
 void TemplateVisitor.valueOf(Expression select, boolean disableOutputEscaping)
           
 void TemplateScreener.visit(Expression expr)
           
 void TemplateScreener.applyTemplates(TemplateRuleList rules, Expression select, Sort sort, Variable[] params)
           
 void TemplateScreener.condition(Expression test, Template content)
           
 void TemplateScreener.copyOf(Expression select)
           
 void TemplateScreener.forEach(Expression select, Sort sort, Template content)
           
 void TemplateScreener.valueOf(Expression select, boolean disableOutputEscaping)
           
 

Constructors in jd.xml.xslt.template with parameters of type Expression
Variable(VariableName name, Expression select, Template template, int type)
          Create a Variable.
ValueOfUnescaped(Expression select)
          Create a ValueOfUnescaped object.
ValueOf(Expression select)
          Create a ValueOf object.
ForEach(Expression select, Sort sort, Template template)
          Create a ForEach object.
CopyOf(Expression select)
          Create the CopyOf object.
Condition(Expression test, Template template)
          Create a Condition.
ApplyTemplates(TemplateRuleList rules, Expression select, Sort sort, Variable[] params)
          Create a new ApplyTemplates object.
 

Uses of Expression in jd.xml.xslt.trace
 

Classes in jd.xml.xslt.trace that implement Expression
(package private)  class TraceExpression
           
 

Methods in jd.xml.xslt.trace that return Expression
 Expression TraceParseListener.expressionParsed(XsltParseContext context, Expression expr, String source)
           
 

Methods in jd.xml.xslt.trace with parameters of type Expression
 void Tracer.expression(Location location, Expression expr, String source)
           
 Expression TraceParseListener.expressionParsed(XsltParseContext context, Expression expr, String source)
           
 

Constructors in jd.xml.xslt.trace with parameters of type Expression
TraceExpression(Tracer tracer, Location location, Expression expression, String source)