Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/AbstractNodeVisitor.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/AbstractNodeVisitor.java?view=auto&rev=158176 ============================================================================== --- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/AbstractNodeVisitor.java (added) +++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/AbstractNodeVisitor.java Fri Mar 18 17:02:29 2005 @@ -0,0 +1,1586 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.jdo.jdoql.tree; + +/** + * This class provides a default implementation for the node visitor pattern. + * Methods having derived nodes as arguments delegate to those methods + * having least derived nodes as arguments. As some visitors do not need + * to know each specific operations, + * they do not need to provide code for those operations. + * In addition to methods defined in the interface <code>NodeVisitor</code> + * this class defines protected methods taking non-leaf nodes in terms of the + * node hierarchy of interfaces. + * + * @author Michael Watzek + */ +public abstract class AbstractNodeVisitor implements NodeVisitor +{ + //protected methods + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>Expression</code>. + * @param node the node to be walked + */ + protected void arrive(BinaryExpression node) + { arrive( (Expression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>Node</code>. + * @param node the node to be walked + */ + protected void arrive(Declaration node) + { arrive( (Node) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>Node</code>. + * @param node the node to be walked + */ + protected void arrive(Expression node) + { arrive( (Node) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>Expression</code>. + * @param node the node to be walked + */ + protected void arrive(MethodCallExpression node) + { arrive( (Expression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>Node</code>. + * @param node the node to be walked + */ + protected void arrive(OrderingExpression node) + { arrive( (Node) node ); + } + + /** + * This method defines the default implementation for all + * <code>arrive</code> methods: It immediately returns without executing + * any other instruction. + * @param node the node to be walked + */ + protected void arrive(Node node) + { return; + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>Expression</code>. + * @param node the node to be walked + */ + protected void arrive(UnaryExpression node) + { arrive( (Expression) node ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>Expression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + protected Object leave(BinaryExpression node, Object[] results) + { return leave( (Expression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>Node</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + protected Object leave(Declaration node, Object[] results) + { return leave( (Node) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>Node</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + protected Object leave(Expression node, Object[] results) + { return leave( (Node) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>Expression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + protected Object leave(MethodCallExpression node, Object[] results) + { return leave( (Expression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>Node</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + protected Object leave(OrderingExpression node, Object[] results) + { return leave( (Node) node, results ); + } + + /** + * This method defines the default implementation for all + * <code>leave</code> methods: It immediately returns <code>null</code> + * without executing any other instruction. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return <code>null</code> + */ + protected Object leave(Node node, Object[] results) + { return null; + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>Expression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + protected Object leave(UnaryExpression node, Object[] results) + { return leave( (Expression) node, results ); + } + + + /** + * This method delegates to <code>walkNextChild</code> casting the argument + * <code>node</code> to <code>Expression</code>. It returns the value + * of that method. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return the result of the delegation call + */ + protected boolean walkNextChild(BinaryExpression node, Object resultOfPreviousChild, int indexOfNextChild) + { return walkNextChild( (Expression) node, resultOfPreviousChild, indexOfNextChild ); + } + + /** + * This method delegates to <code>walkNextChild</code> casting the argument + * <code>node</code> to <code>Node</code>. It returns the value + * of that method. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return the result of the delegation call + */ + protected boolean walkNextChild(Expression node, Object resultOfPreviousChild, int indexOfNextChild) + { return walkNextChild( (Node) node, resultOfPreviousChild, indexOfNextChild ); + } + + /** + * This method delegates to <code>walkNextChild</code> casting the argument + * <code>node</code> to <code>Expression</code>. It returns the value + * of that method. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return the result of the delegation call + */ + protected boolean walkNextChild(IdentifierExpression node, Object resultOfPreviousChild, int indexOfNextChild) + { return walkNextChild( (Expression) node, resultOfPreviousChild, indexOfNextChild ); + } + + /** + * This method delegates to <code>walkNextChild</code> casting the argument + * <code>node</code> to <code>Expression</code>. It returns the value + * of that method. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return the result of the delegation call + */ + protected boolean walkNextChild(MethodCallExpression node, Object resultOfPreviousChild, int indexOfNextChild) + { return walkNextChild( (Expression) node, resultOfPreviousChild, indexOfNextChild ); + } + + /** + * This method defines the default implementation for all + * <code>walkNextChild</code> methods: It immediately returns <code>true</code> + * without executing any other instruction. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return <code>true</code> + */ + protected boolean walkNextChild(Node node, Object resultOfPreviousChild, int indexOfNextChild) + { return true; + } + + /** + * This method delegates to <code>walkNextChild</code> casting the argument + * <code>node</code> to <code>Node</code>. It returns the value + * of that method. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return the result of the delegation call + */ + protected boolean walkNextChild(OrderingExpression node, Object resultOfPreviousChild, int indexOfNextChild) + { return walkNextChild( (Node) node, resultOfPreviousChild, indexOfNextChild ); + } + + /** + * This method delegates to <code>walkNextChild</code> casting the argument + * <code>node</code> to <code>Expression</code>. It returns the value + * of that method. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return the result of the delegation call + */ + protected boolean walkNextChild(UnaryExpression node, Object resultOfPreviousChild, int indexOfNextChild) + { return walkNextChild( (Expression) node, resultOfPreviousChild, indexOfNextChild ); + } + + //public methods + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. + * @param node the node to be walked + */ + public void arrive(AndExpression node) + { arrive( (BinaryExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>OrderingExpression</code>. + * @param node the node to be walked + */ + public void arrive(AscendingOrderingExpression node) + { arrive( (OrderingExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>ConstantExpression</code>. + * @param node the node to be walked + */ + public void arrive(BooleanLiteralExpression node) + { arrive( (ConstantExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>ConstantExpression</code>. + * @param node the node to be walked + */ + public void arrive(ByteLiteralExpression node) + { arrive( (ConstantExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>Node</code>. + * @param node the node to be walked + */ + public void arrive(CandidateClass node) + { arrive( (Node) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>Expression</code>. + * @param node the node to be walked + */ + public void arrive(CastExpression node) + { arrive( (Expression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>ConstantExpression</code>. + * @param node the node to be walked + */ + public void arrive(CharLiteralExpression node) + { arrive( (ConstantExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>UnaryExpression</code>. + * @param node the node to be walked + */ + public void arrive(ComplementExpression node) + { arrive( (UnaryExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. + * @param node the node to be walked + */ + public void arrive(ConditionalAndExpression node) + { arrive( (BinaryExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. + * @param node the node to be walked + */ + public void arrive(ConditionalOrExpression node) + { arrive( (BinaryExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>Expression</code>. + * @param node the node to be walked + */ + public void arrive(ConstantExpression node) + { arrive( (Expression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>MethodCallExpression</code>. + * @param node the node to be walked + */ + public void arrive(ContainsCallExpression node) + { arrive( (MethodCallExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>OrderingExpression</code>. + * @param node the node to be walked + */ + public void arrive(DescendingOrderingExpression node) + { arrive( (OrderingExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. + * @param node the node to be walked + */ + public void arrive(DivideExpression node) + { arrive( (BinaryExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>ConstantExpression</code>. + * @param node the node to be walked + */ + public void arrive(DoubleLiteralExpression node) + { arrive( (ConstantExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. + * @param node the node to be walked + */ + public void arrive(EqualsExpression node) + { arrive( (BinaryExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>MethodCallExpression</code>. + * @param node the node to be walked + */ + public void arrive(EndsWithCallExpression node) + { arrive( (MethodCallExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>IdentifierExpression</code>. + * @param node the node to be walked + */ + public void arrive(FieldAccessExpression node) + { arrive( (IdentifierExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>ConstantExpression</code>. + * @param node the node to be walked + */ + public void arrive(FloatLiteralExpression node) + { arrive( (ConstantExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. + * @param node the node to be walked + */ + public void arrive(GreaterThanEqualsExpression node) + { arrive( (BinaryExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. + * @param node the node to be walked + */ + public void arrive(GreaterThanExpression node) + { arrive( (BinaryExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>Expression</code>. + * @param node the node to be walked + */ + public void arrive(IdentifierExpression node) + { arrive( (Expression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>ConstantExpression</code>. + * @param node the node to be walked + */ + public void arrive(IntLiteralExpression node) + { arrive( (ConstantExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>MethodCallExpression</code>. + * @param node the node to be walked + */ + public void arrive(IsEmptyCallExpression node) + { arrive( (MethodCallExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. + * @param node the node to be walked + */ + public void arrive(LessThanEqualsExpression node) + { arrive( (BinaryExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. + * @param node the node to be walked + */ + public void arrive(LessThanExpression node) + { arrive( (BinaryExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>ConstantExpression</code>. + * @param node the node to be walked + */ + public void arrive(LongLiteralExpression node) + { arrive( (ConstantExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. + * @param node the node to be walked + */ + public void arrive(MinusExpression node) + { arrive( (BinaryExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. + * @param node the node to be walked + */ + public void arrive(NotEqualsExpression node) + { arrive( (BinaryExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>UnaryExpression</code>. + * @param node the node to be walked + */ + public void arrive(NotExpression node) + { arrive( (UnaryExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. + * @param node the node to be walked + */ + public void arrive(OrExpression node) + { arrive( (BinaryExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>IdentifierExpression</code>. + * @param node the node to be walked + */ + public void arrive(ParameterAccessExpression node) + { arrive( (IdentifierExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>Declaration</code>. + * @param node the node to be walked + */ + public void arrive(ParameterDeclaration node) + { arrive( (Declaration) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. + * @param node the node to be walked + */ + public void arrive(PlusExpression node) + { arrive( (BinaryExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>Node</code>. + * @param node the node to be walked + */ + public void arrive(QueryTree node) + { arrive( (Node) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>ConstantExpression</code>. + * @param node the node to be walked + */ + public void arrive(ShortLiteralExpression node) + { arrive( (ConstantExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>MethodCallExpression</code>. + * @param node the node to be walked + */ + public void arrive(StartsWithCallExpression node) + { arrive( (MethodCallExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>FieldAccessExpression</code>. + * @param node the node to be walked + */ + public void arrive(StaticFieldAccessExpression node) + { arrive( (FieldAccessExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>IdentifierExpression</code>. + * @param node the node to be walked + */ + public void arrive(ThisExpression node) + { arrive( (IdentifierExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. + * @param node the node to be walked + */ + public void arrive(TimesExpression node) + { arrive( (BinaryExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>Node</code>. + * @param node the node to be walked + */ + public void arrive(Type node) + { arrive( (Node) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>UnaryExpression</code>. + * @param node the node to be walked + */ + public void arrive(UnaryMinusExpression node) + { arrive( (UnaryExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>UnaryExpression</code>. + * @param node the node to be walked + */ + public void arrive(UnaryPlusExpression node) + { arrive( (UnaryExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>IdentifierExpression</code>. + * @param node the node to be walked + */ + public void arrive(VariableAccessExpression node) + { arrive( (IdentifierExpression) node ); + } + + /** + * This method delegates to <code>arrive</code> casting the argument + * <code>node</code> to <code>Declaration</code>. + * @param node the node to be walked + */ + public void arrive(VariableDeclaration node) + { arrive( (Declaration) node ); + } + + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(AndExpression node, Object[] results) + { return leave( (BinaryExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>OrderingExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(AscendingOrderingExpression node, Object[] results) + { return leave( (OrderingExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>ConstantExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(BooleanLiteralExpression node, Object[] results) + { return leave( (ConstantExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>ConstantExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(ByteLiteralExpression node, Object[] results) + { return leave( (ConstantExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>Node</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(CandidateClass node, Object[] results) + { return leave( (Node) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>Expression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(CastExpression node, Object[] results) + { return leave( (Expression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>ConstantExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(CharLiteralExpression node, Object[] results) + { return leave( (ConstantExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>UnaryExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(ComplementExpression node, Object[] results) + { return leave( (UnaryExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(ConditionalAndExpression node, Object[] results) + { return leave( (BinaryExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(ConditionalOrExpression node, Object[] results) + { return leave( (BinaryExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>Expression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(ConstantExpression node, Object[] results) + { return leave( (Expression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>MethodCallExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(ContainsCallExpression node, Object[] results) + { return leave( (MethodCallExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>OrderingExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(DescendingOrderingExpression node, Object[] results) + { return leave( (OrderingExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(DivideExpression node, Object[] results) + { return leave( (BinaryExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>ConstantExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(DoubleLiteralExpression node, Object[] results) + { return leave( (ConstantExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>MethodCallExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(EndsWithCallExpression node, Object[] results) + { return leave( (MethodCallExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(EqualsExpression node, Object[] results) + { return leave( (BinaryExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>IdentifierExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(FieldAccessExpression node, Object[] results) + { return leave( (IdentifierExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>ConstantExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(FloatLiteralExpression node, Object[] results) + { return leave( (ConstantExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(GreaterThanEqualsExpression node, Object[] results) + { return leave( (BinaryExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(GreaterThanExpression node, Object[] results) + { return leave( (BinaryExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>Expression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(IdentifierExpression node, Object[] results) + { return leave( (Expression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>ConstantExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(IntLiteralExpression node, Object[] results) + { return leave( (ConstantExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>MethodCallExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(IsEmptyCallExpression node, Object[] results) + { return leave( (MethodCallExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(LessThanEqualsExpression node, Object[] results) + { return leave( (BinaryExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(LessThanExpression node, Object[] results) + { return leave( (BinaryExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>ConstantExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(LongLiteralExpression node, Object[] results) + { return leave( (ConstantExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(MinusExpression node, Object[] results) + { return leave( (BinaryExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(NotEqualsExpression node, Object[] results) + { return leave( (BinaryExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>UnaryExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(NotExpression node, Object[] results) + { return leave( (UnaryExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(OrExpression node, Object[] results) + { return leave( (BinaryExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>IdentifierExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(ParameterAccessExpression node, Object[] results) + { return leave( (IdentifierExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>Declaration</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(ParameterDeclaration node, Object[] results) + { return leave( (Declaration) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(PlusExpression node, Object[] results) + { return leave( (BinaryExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>Node</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(QueryTree node, Object[] results) + { return leave( (Node) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>ConstantExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(ShortLiteralExpression node, Object[] results) + { return leave( (ConstantExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>MethodCallExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(StartsWithCallExpression node, Object[] results) + { return leave( (MethodCallExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>FieldAccessExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(StaticFieldAccessExpression node, Object[] results) + { return leave( (FieldAccessExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>IdentifierExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(ThisExpression node, Object[] results) + { return leave( (IdentifierExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(TimesExpression node, Object[] results) + { return leave( (BinaryExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>Node</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(Type node, Object[] results) + { return leave( (Node) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>UnaryExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(UnaryMinusExpression node, Object[] results) + { return leave( (UnaryExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>UnaryExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(UnaryPlusExpression node, Object[] results) + { return leave( (UnaryExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>IdentifierExpression</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(VariableAccessExpression node, Object[] results) + { return leave( (IdentifierExpression) node, results ); + } + + /** + * This method delegates to <code>leave</code> casting the argument + * <code>node</code> to <code>Declaration</code>. It returns the value + * of that method. + * @param node the node having been walked + * @param results the results of walking the node's children + * @return the result of the delegation call + */ + public Object leave(VariableDeclaration node, Object[] results) + { return leave( (Declaration) node, results ); + } + + /** + * This method delegates to <code>walkNextChild</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. It returns the value + * of that method. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return the result of the delegation call + */ + public boolean walkNextChild(AndExpression node, Object resultOfPreviousChild, int indexOfNextChild) + { return walkNextChild( (BinaryExpression) node, resultOfPreviousChild, indexOfNextChild ); + } + + /** + * This method delegates to <code>walkNextChild</code> casting the argument + * <code>node</code> to <code>OrderingExpression</code>. It returns the value + * of that method. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return the result of the delegation call + */ + public boolean walkNextChild(AscendingOrderingExpression node, Object resultOfPreviousChild, int indexOfNextChild) + { return walkNextChild( (OrderingExpression) node, resultOfPreviousChild, indexOfNextChild ); + } + + /** + * This method delegates to <code>walkNextChild</code> casting the argument + * <code>node</code> to <code>Expression</code>. It returns the value + * of that method. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return the result of the delegation call + */ + public boolean walkNextChild(CastExpression node, Object resultOfPreviousChild, int indexOfNextChild) + { return walkNextChild( (Expression) node, resultOfPreviousChild, indexOfNextChild ); + } + + /** + * This method delegates to <code>walkNextChild</code> casting the argument + * <code>node</code> to <code>UnaryExpression</code>. It returns the value + * of that method. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return the result of the delegation call + */ + public boolean walkNextChild(ComplementExpression node, Object resultOfPreviousChild, int indexOfNextChild) + { return walkNextChild( (UnaryExpression) node, resultOfPreviousChild, indexOfNextChild ); + } + + /** + * This method delegates to <code>walkNextChild</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. It returns the value + * of that method. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return the result of the delegation call + */ + public boolean walkNextChild(ConditionalAndExpression node, Object resultOfPreviousChild, int indexOfNextChild) + { return walkNextChild( (BinaryExpression) node, resultOfPreviousChild, indexOfNextChild ); + } + + /** + * This method delegates to <code>walkNextChild</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. It returns the value + * of that method. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return the result of the delegation call + */ + public boolean walkNextChild(ConditionalOrExpression node, Object resultOfPreviousChild, int indexOfNextChild) + { return walkNextChild( (BinaryExpression) node, resultOfPreviousChild, indexOfNextChild ); + } + + /** + * This method delegates to <code>walkNextChild</code> casting the argument + * <code>node</code> to <code>MethodCallExpression</code>. It returns the value + * of that method. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return the result of the delegation call + */ + public boolean walkNextChild(ContainsCallExpression node, Object resultOfPreviousChild, int indexOfNextChild) + { return walkNextChild( (MethodCallExpression) node, resultOfPreviousChild, indexOfNextChild ); + } + + /** + * This method delegates to <code>walkNextChild</code> casting the argument + * <code>node</code> to <code>OrderingExpression</code>. It returns the value + * of that method. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return the result of the delegation call + */ + public boolean walkNextChild(DescendingOrderingExpression node, Object resultOfPreviousChild, int indexOfNextChild) + { return walkNextChild( (OrderingExpression) node, resultOfPreviousChild, indexOfNextChild ); + } + + /** + * This method delegates to <code>walkNextChild</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. It returns the value + * of that method. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return the result of the delegation call + */ + public boolean walkNextChild(DivideExpression node, Object resultOfPreviousChild, int indexOfNextChild) + { return walkNextChild( (BinaryExpression) node, resultOfPreviousChild, indexOfNextChild ); + } + + /** + * This method delegates to <code>walkNextChild</code> casting the argument + * <code>node</code> to <code>MethodCallExpression</code>. It returns the value + * of that method. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return the result of the delegation call + */ + public boolean walkNextChild(EndsWithCallExpression node, Object resultOfPreviousChild, int indexOfNextChild) + { return walkNextChild( (MethodCallExpression) node, resultOfPreviousChild, indexOfNextChild ); + } + + /** + * This method delegates to <code>walkNextChild</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. It returns the value + * of that method. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return the result of the delegation call + */ + public boolean walkNextChild(EqualsExpression node, Object resultOfPreviousChild, int indexOfNextChild) + { return walkNextChild( (BinaryExpression) node, resultOfPreviousChild, indexOfNextChild ); + } + + /** + * This method delegates to <code>walkNextChild</code> casting the argument + * <code>node</code> to <code>IdentifierExpression</code>. It returns the value + * of that method. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return the result of the delegation call + */ + public boolean walkNextChild(FieldAccessExpression node, Object resultOfPreviousChild, int indexOfNextChild) + { return walkNextChild( (IdentifierExpression) node, resultOfPreviousChild, indexOfNextChild ); + } + + /** + * This method delegates to <code>walkNextChild</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. It returns the value + * of that method. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return the result of the delegation call + */ + public boolean walkNextChild(GreaterThanEqualsExpression node, Object resultOfPreviousChild, int indexOfNextChild) + { return walkNextChild( (BinaryExpression) node, resultOfPreviousChild, indexOfNextChild ); + } + + /** + * This method delegates to <code>walkNextChild</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. It returns the value + * of that method. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return the result of the delegation call + */ + public boolean walkNextChild(GreaterThanExpression node, Object resultOfPreviousChild, int indexOfNextChild) + { return walkNextChild( (BinaryExpression) node, resultOfPreviousChild, indexOfNextChild ); + } + + /** + * This method delegates to <code>walkNextChild</code> casting the argument + * <code>node</code> to <code>MethodCallExpression</code>. It returns the value + * of that method. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return the result of the delegation call + */ + public boolean walkNextChild(IsEmptyCallExpression node, Object resultOfPreviousChild, int indexOfNextChild) + { return walkNextChild( (MethodCallExpression) node, resultOfPreviousChild, indexOfNextChild ); + } + + /** + * This method delegates to <code>walkNextChild</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. It returns the value + * of that method. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return the result of the delegation call + */ + public boolean walkNextChild(LessThanEqualsExpression node, Object resultOfPreviousChild, int indexOfNextChild) + { return walkNextChild( (BinaryExpression) node, resultOfPreviousChild, indexOfNextChild ); + } + + /** + * This method delegates to <code>walkNextChild</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. It returns the value + * of that method. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return the result of the delegation call + */ + public boolean walkNextChild(LessThanExpression node, Object resultOfPreviousChild, int indexOfNextChild) + { return walkNextChild( (BinaryExpression) node, resultOfPreviousChild, indexOfNextChild ); + } + + /** + * This method delegates to <code>walkNextChild</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. It returns the value + * of that method. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return the result of the delegation call + */ + public boolean walkNextChild(MinusExpression node, Object resultOfPreviousChild, int indexOfNextChild) + { return walkNextChild( (BinaryExpression) node, resultOfPreviousChild, indexOfNextChild ); + } + + /** + * This method delegates to <code>walkNextChild</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. It returns the value + * of that method. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return the result of the delegation call + */ + public boolean walkNextChild(NotEqualsExpression node, Object resultOfPreviousChild, int indexOfNextChild) + { return walkNextChild( (BinaryExpression) node, resultOfPreviousChild, indexOfNextChild ); + } + + /** + * This method delegates to <code>walkNextChild</code> casting the argument + * <code>node</code> to <code>UnaryExpression</code>. It returns the value + * of that method. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return the result of the delegation call + */ + public boolean walkNextChild(NotExpression node, Object resultOfPreviousChild, int indexOfNextChild) + { return walkNextChild( (UnaryExpression) node, resultOfPreviousChild, indexOfNextChild ); + } + + /** + * This method delegates to <code>walkNextChild</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. It returns the value + * of that method. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return the result of the delegation call + */ + public boolean walkNextChild(OrExpression node, Object resultOfPreviousChild, int indexOfNextChild) + { return walkNextChild( (BinaryExpression) node, resultOfPreviousChild, indexOfNextChild ); + } + + /** + * This method delegates to <code>walkNextChild</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. It returns the value + * of that method. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return the result of the delegation call + */ + public boolean walkNextChild(PlusExpression node, Object resultOfPreviousChild, int indexOfNextChild) + { return walkNextChild( (BinaryExpression) node, resultOfPreviousChild, indexOfNextChild ); + } + + /** + * This method delegates to <code>walkNextChild</code> casting the argument + * <code>node</code> to <code>Node</code>. It returns the value + * of that method. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return the result of the delegation call + */ + public boolean walkNextChild(QueryTree node, Object resultOfPreviousChild, int indexOfNextChild) + { return walkNextChild( (Node) node, resultOfPreviousChild, indexOfNextChild ); + } + + /** + * This method delegates to <code>walkNextChild</code> casting the argument + * <code>node</code> to <code>MethodCallExpression</code>. It returns the value + * of that method. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return the result of the delegation call + */ + public boolean walkNextChild(StartsWithCallExpression node, Object resultOfPreviousChild, int indexOfNextChild) + { return walkNextChild( (MethodCallExpression) node, resultOfPreviousChild, indexOfNextChild ); + } + + /** + * This method delegates to <code>walkNextChild</code> casting the argument + * <code>node</code> to <code>FieldAccessExpression</code>. It returns the value + * of that method. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return the result of the delegation call + */ + public boolean walkNextChild(StaticFieldAccessExpression node, Object resultOfPreviousChild, int indexOfNextChild) + { return walkNextChild( (FieldAccessExpression) node, resultOfPreviousChild, indexOfNextChild ); + } + + /** + * This method delegates to <code>walkNextChild</code> casting the argument + * <code>node</code> to <code>BinaryExpression</code>. It returns the value + * of that method. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return the result of the delegation call + */ + public boolean walkNextChild(TimesExpression node, Object resultOfPreviousChild, int indexOfNextChild) + { return walkNextChild( (BinaryExpression) node, resultOfPreviousChild, indexOfNextChild ); + } + + /** + * This method delegates to <code>walkNextChild</code> casting the argument + * <code>node</code> to <code>UnaryExpression</code>. It returns the value + * of that method. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return the result of the delegation call + */ + public boolean walkNextChild(UnaryMinusExpression node, Object resultOfPreviousChild, int indexOfNextChild) + { return walkNextChild( (UnaryExpression) node, resultOfPreviousChild, indexOfNextChild ); + } + + /** + * This method delegates to <code>walkNextChild</code> casting the argument + * <code>node</code> to <code>UnaryExpression</code>. It returns the value + * of that method. + * @param node the parent node of the children currently walked + * @param resultOfPreviousChild the result of walking the node's previous child + * @param indexOfNextChild the index of the next child to be walked + * @return the result of the delegation call + */ + public boolean walkNextChild(UnaryPlusExpression node, Object resultOfPreviousChild, int indexOfNextChild) + { return walkNextChild( (UnaryExpression) node, resultOfPreviousChild, indexOfNextChild ); + } +}
Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/AndExpression.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/AndExpression.java?view=auto&rev=158176 ============================================================================== --- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/AndExpression.java (added) +++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/AndExpression.java Fri Mar 18 17:02:29 2005 @@ -0,0 +1,29 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.jdo.jdoql.tree; + +/** + * This node represents a bitwise or logical and operator depending on the result + * types of its children. A bitwise operator is based on arithmetical types. + * In contrast, a logical operator is based on boolean types. + * The string representation of this operator is <code>&</code>. + * + * @author Michael Watzek + */ +public interface AndExpression extends BinaryExpression +{ +} Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/AscendingOrderingExpression.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/AscendingOrderingExpression.java?view=auto&rev=158176 ============================================================================== --- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/AscendingOrderingExpression.java (added) +++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/AscendingOrderingExpression.java Fri Mar 18 17:02:29 2005 @@ -0,0 +1,29 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.jdo.jdoql.tree; + +/** + * This node represents an operator defining ascendent ordering of instances + * returned by a query execution. The order is determined by an expression + * such as <code>FieldAccessExpression</code>. This expression is this node's + * child. + * + * @author Michael Watzek + */ +public interface AscendingOrderingExpression extends OrderingExpression +{ +} Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/BinaryExpression.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/BinaryExpression.java?view=auto&rev=158176 ============================================================================== --- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/BinaryExpression.java (added) +++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/BinaryExpression.java Fri Mar 18 17:02:29 2005 @@ -0,0 +1,52 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.jdo.jdoql.tree; + +/** + * This node expression represents a binary operator. All binary operators have exactly + * two children. Examples of binary operators + * are <code>AndExpression</code> and <code>EqualsExpression</code>. + * + * @author Michael Watzek + */ +public interface BinaryExpression extends Expression +{ + /** + * Returns the first child of this node. + * @return the first child + */ + public Expression getLeftExpression(); + + /** + * Returns the second child of this node. + * @return the second child + */ + public Expression getRightExpression(); + + /** + * Returns the class instance suiteable for implementing the result + * of this expression. In case of integral binary expressions + * that class instance is also the result type of the operation retrieved + * by method <code>getJavaClass</code>. In case of relational binary + * expressions, that class instance differs from the type retrieved by + * <code>getJavaClass</code>, because relational binary expressions + * have a boolean result type which does not depend of the operand types. + * @return the common operand type + */ + public Class getCommonOperandType(); +} + Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/BooleanLiteralExpression.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/BooleanLiteralExpression.java?view=auto&rev=158176 ============================================================================== --- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/BooleanLiteralExpression.java (added) +++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/BooleanLiteralExpression.java Fri Mar 18 17:02:29 2005 @@ -0,0 +1,32 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.jdo.jdoql.tree; + +/** + * This node represents a boolean literal such as <code>true</code> or + * <code>false</code>. It does not have any children. + * + * @author Michael Watzek + */ +public interface BooleanLiteralExpression extends ConstantExpression +{ + /** + * Returns the boolean value represented by this expression. + * @return the boolean value + */ + public boolean getBoolean(); +} Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/ByteLiteralExpression.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/ByteLiteralExpression.java?view=auto&rev=158176 ============================================================================== --- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/ByteLiteralExpression.java (added) +++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/ByteLiteralExpression.java Fri Mar 18 17:02:29 2005 @@ -0,0 +1,31 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.jdo.jdoql.tree; + +/** + * This node represents a byte literal. It does not have any children. + * + * @author Michael Watzek + */ +public interface ByteLiteralExpression extends ConstantExpression +{ + /** + * Returns the byte value represented by this expression. + * @return the byte value + */ + public byte getByte(); +} \ No newline at end of file Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/CandidateClass.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/CandidateClass.java?view=auto&rev=158176 ============================================================================== --- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/CandidateClass.java (added) +++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/CandidateClass.java Fri Mar 18 17:02:29 2005 @@ -0,0 +1,29 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.jdo.jdoql.tree; + +/** + * This node represents the candidate class of a query. + * The candidate class defines the type of instances in the + * candidate collection on which the filter expression is applied. + * This node does not have nay children. + * + * @author Michael Watzek + */ +public interface CandidateClass extends Node +{ +} Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/CastExpression.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/CastExpression.java?view=auto&rev=158176 ============================================================================== --- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/CastExpression.java (added) +++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/CastExpression.java Fri Mar 18 17:02:29 2005 @@ -0,0 +1,39 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.jdo.jdoql.tree; + +/** + * This node represents a cast expression. It has a result type and a child + * which corresponds with the expression to cast. + * + * @author Michael Watzek + */ +public interface CastExpression extends Expression +{ + /** + * Returns the string representation of the Java class, + * to which this node's expression is casted. + * @return the Java type name + */ + public String getTypeName(); + + /** + * Returns the node's cast expression. + * @return the node's cast expression + */ + public Expression getExpression(); +} Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/CharLiteralExpression.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/CharLiteralExpression.java?view=auto&rev=158176 ============================================================================== --- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/CharLiteralExpression.java (added) +++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/CharLiteralExpression.java Fri Mar 18 17:02:29 2005 @@ -0,0 +1,31 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.jdo.jdoql.tree; + +/** + * This node represents a character literal. It does not have any children. + * + * @author Michael Watzek + */ +public interface CharLiteralExpression extends ConstantExpression +{ + /** + * Returns the char value represented by this expression. + * @return the char value + */ + public char getChar(); +} \ No newline at end of file Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/ComplementExpression.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/ComplementExpression.java?view=auto&rev=158176 ============================================================================== --- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/ComplementExpression.java (added) +++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/ComplementExpression.java Fri Mar 18 17:02:29 2005 @@ -0,0 +1,28 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.jdo.jdoql.tree; + +/** + * This node represents a bitwise not operator. + * A bitwise not operator is a unary expression. + * The string representation of this operator is <code>~</code>. + * + * @author Michael Watzek + */ +public interface ComplementExpression extends UnaryExpression +{ +} Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/ConditionalAndExpression.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/ConditionalAndExpression.java?view=auto&rev=158176 ============================================================================== --- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/ConditionalAndExpression.java (added) +++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/ConditionalAndExpression.java Fri Mar 18 17:02:29 2005 @@ -0,0 +1,28 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.jdo.jdoql.tree; + +/** + * This node represents a conditional and operator. + * A conditional and operator is a binary expression. + * The string representation of this operator is <code>&&</code>. + * + * @author Michael Watzek + */ +public interface ConditionalAndExpression extends BinaryExpression +{ +} Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/ConditionalOrExpression.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/ConditionalOrExpression.java?view=auto&rev=158176 ============================================================================== --- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/ConditionalOrExpression.java (added) +++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/ConditionalOrExpression.java Fri Mar 18 17:02:29 2005 @@ -0,0 +1,28 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.jdo.jdoql.tree; + +/** + * This node represents a conditional or operator. + * A conditional or operator is a binary expression. + * The string representation of this operator is <code>||</code>. + * + * @author Michael Watzek + */ +public interface ConditionalOrExpression extends BinaryExpression +{ +} Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/ConstantExpression.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/ConstantExpression.java?view=auto&rev=158176 ============================================================================== --- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/ConstantExpression.java (added) +++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/ConstantExpression.java Fri Mar 18 17:02:29 2005 @@ -0,0 +1,33 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.jdo.jdoql.tree; + +/** + * This node represents a constant expression. + * Examples of constant expressions are <code>BooleanLiteralExpression</code> or + * <code>ByteLiteralExpression</code>. It does not have any children. + * + * @author Michael Watzek + */ +public interface ConstantExpression extends Expression +{ + /** + * Returns the value represented by this expression. + * @return the value + */ + public Object getValue(); +} Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/ContainsCallExpression.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/ContainsCallExpression.java?view=auto&rev=158176 ============================================================================== --- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/ContainsCallExpression.java (added) +++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/ContainsCallExpression.java Fri Mar 18 17:02:29 2005 @@ -0,0 +1,29 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.jdo.jdoql.tree; + +/** + * This node represents the method call expression + * <code>Collection.contains</code>. Children of this node are a target + * expression (e.g. a <code>FieldAccessExpression</code>) and the method + * argument which is an arbitrary expression. + * + * @author Michael Watzek + */ +public interface ContainsCallExpression extends MethodCallExpression +{ +}
