svn commit: r171353 [12/13] - in /incubator/jdo/trunk/query20: ./ src/ src/conf/ src/java/ src/java/org/ src/java/org/apache/ src/java/org/apache/jdo/ src/java/org/apache/jdo/impl/ src/java/org/apache/jdo/impl/jdoql/ src/java/org/apache/jdo/impl/jdoql/jdoqlc/ src/java/org/apache/jdo/impl/jdoql/scope/ src/java/org/apache/jdo/impl/jdoql/tree/ src/java/org/apache/jdo/jdoql/ src/java/org/apache/jdo/jdoql/tree/

[mb...@apache.org]

Added: incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/NodeVisitor.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/NodeVisitor.java?rev=171353&view=auto
==============================================================================
--- incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/NodeVisitor.java (added)
+++ incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/NodeVisitor.java Sun May 22 11:08:57 2005
@@ -0,0 +1,1676 @@
+/*
+ * 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 interface defines three categories of methods for each query tree node.
+ * These methods are called during walking the tree:
+ * <code>arrive</code>: This method is meant for initialization purposes
+ * and is called before walking a node's children.
+ * <code>leave</code>: This method is meant for calculation purposes
+ * and is called after walking a node's children.
+ * <code>walkNextChild</code>: This method is called before walking
+ * each child of a node. It can be used to control whether
+ * the a node's remaining children should be walked.
+ *
+ * @author Michael Watzek
+ */
+public interface NodeVisitor
+{
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(AndExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(AscendingOrderingExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(BooleanLiteralExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(ByteLiteralExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(CandidateClass node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(CastExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(CharLiteralExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(ComplementExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(ConditionalAndExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(ConditionalOrExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(ConstantExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(ContainsCallExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(DescendingOrderingExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(DivideExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(DoubleLiteralExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(EndsWithCallExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(EqualsExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(FieldAccessExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(StaticFieldAccessExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(FloatLiteralExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(GreaterThanEqualsExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(GreaterThanExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(IdentifierExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(IntLiteralExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(IsEmptyCallExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(LessThanEqualsExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(LessThanExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(LongLiteralExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(MinusExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(NotEqualsExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(NotExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(OrExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(ParameterAccessExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(ParameterDeclaration node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(PlusExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(QueryTree node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(ShortLiteralExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(StartsWithCallExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(ThisExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(TimesExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(Type node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(UnaryMinusExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(UnaryPlusExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(VariableAccessExpression node);
+
+    /**
+     * This method is called before walking any children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to perform any initialization tasks it needs for walking the node's
+     * children.
+     * @param node the node to be walked
+     */
+    public void arrive(VariableDeclaration node);
+
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(AndExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(AscendingOrderingExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(BooleanLiteralExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(ByteLiteralExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(CandidateClass node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(CastExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(CharLiteralExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(ComplementExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(ConditionalAndExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(ConditionalOrExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(ConstantExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(ContainsCallExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(DescendingOrderingExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(DivideExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(DoubleLiteralExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(EqualsExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(EndsWithCallExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(FieldAccessExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(StaticFieldAccessExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(FloatLiteralExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(GreaterThanEqualsExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(GreaterThanExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(IdentifierExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(IntLiteralExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(IsEmptyCallExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(LessThanEqualsExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(LessThanExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(LongLiteralExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(MinusExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(NotEqualsExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(NotExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(OrExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(ParameterAccessExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(ParameterDeclaration node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(PlusExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(QueryTree node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(ShortLiteralExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(StartsWithCallExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(ThisExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(TimesExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(Type node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(UnaryMinusExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(UnaryPlusExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(VariableAccessExpression node, Object[] results);
+
+    /**
+     * This method is called after walking the children of the argument
+     * <code>node</code>. A node visitor instance uses this method
+     * to compute the result of walking the argument <code>node</code>
+     * and it's children. This result is returned by the tree walker's
+     * <code>walk</code> method. The argument <code>results</code> holds
+     * the results of walking the children of the argument <code>node</code>.
+     * Usually, the result of the argument <code>node</code> is computed in
+     * consideration of the results of its' children.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of walking the node and it's children
+     */
+    public Object leave(VariableDeclaration node, Object[] results);
+
+
+    /**
+     * This method is called before walking each child of the argument
+     * <code>node</code>. The return value of this method determines if
+     * the next child of the argument <code>node</code> should be walked.
+     * In case of returning <code>false</code>, none of the remaining
+     * children are walked. Instead, the node's leave method is called
+     * immediately. The argument <code>resultOfPreviousChild</code>
+     * holds the result of walking the previous child of the argument
+     * <code>node</code>. Usually, it is used to determine the return value
+     * of this method. The argument <code>indexOfNextChild</code>
+     * determines the index of the next child to be walked. This index
+     * determines the position in the children array of the argument <code>node</code>.
+     * Note: The index of the first child is 0.
+     * @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>false</code>, if no more childs should be walked, else <code>true</code>
+     */
+    public boolean walkNextChild(AndExpression node, Object resultOfPreviousChild, int indexOfNextChild);
+
+    /**
+     * This method is called before walking each child of the argument
+     * <code>node</code>. The return value of this method determines if
+     * the next child of the argument <code>node</code> should be walked.
+     * In case of returning <code>false</code>, none of the remaining
+     * children are walked. Instead, the node's leave method is called
+     * immediately. The argument <code>resultOfPreviousChild</code>
+     * holds the result of walking the previous child of the argument
+     * <code>node</code>. Usually, it is used to determine the return value
+     * of this method. The argument <code>indexOfNextChild</code>
+     * determines the index of the next child to be walked. This index
+     * determines the position in the children array of the argument <code>node</code>.
+     * Note: The index of the first child is 0.
+     * @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>false</code>, if no more childs should be walked, else <code>true</code>
+     */
+    public boolean walkNextChild(AscendingOrderingExpression node, Object resultOfPreviousChild, int indexOfNextChild);
+
+    /**
+     * This method is called before walking each child of the argument
+     * <code>node</code>. The return value of this method determines if
+     * the next child of the argument <code>node</code> should be walked.
+     * In case of returning <code>false</code>, none of the remaining
+     * children are walked. Instead, the node's leave method is called
+     * immediately. The argument <code>resultOfPreviousChild</code>
+     * holds the result of walking the previous child of the argument
+     * <code>node</code>. Usually, it is used to determine the return value
+     * of this method. The argument <code>indexOfNextChild</code>
+     * determines the index of the next child to be walked. This index
+     * determines the position in the children array of the argument <code>node</code>.
+     * Note: The index of the first child is 0.
+     * @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>false</code>, if no more childs should be walked, else <code>true</code>
+     */
+    public boolean walkNextChild(CastExpression node, Object resultOfPreviousChild, int indexOfNextChild);
+
+    /**
+     * This method is called before walking each child of the argument
+     * <code>node</code>. The return value of this method determines if
+     * the next child of the argument <code>node</code> should be walked.
+     * In case of returning <code>false</code>, none of the remaining
+     * children are walked. Instead, the node's leave method is called
+     * immediately. The argument <code>resultOfPreviousChild</code>
+     * holds the result of walking the previous child of the argument
+     * <code>node</code>. Usually, it is used to determine the return value
+     * of this method. The argument <code>indexOfNextChild</code>
+     * determines the index of the next child to be walked. This index
+     * determines the position in the children array of the argument <code>node</code>.
+     * Note: The index of the first child is 0.
+     * @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>false</code>, if no more childs should be walked, else <code>true</code>
+     */
+    public boolean walkNextChild(ComplementExpression node, Object resultOfPreviousChild, int indexOfNextChild);
+
+    /**
+     * This method is called before walking each child of the argument
+     * <code>node</code>. The return value of this method determines if
+     * the next child of the argument <code>node</code> should be walked.
+     * In case of returning <code>false</code>, none of the remaining
+     * children are walked. Instead, the node's leave method is called
+     * immediately. The argument <code>resultOfPreviousChild</code>
+     * holds the result of walking the previous child of the argument
+     * <code>node</code>. Usually, it is used to determine the return value
+     * of this method. The argument <code>indexOfNextChild</code>
+     * determines the index of the next child to be walked. This index
+     * determines the position in the children array of the argument <code>node</code>.
+     * Note: The index of the first child is 0.
+     * @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>false</code>, if no more childs should be walked, else <code>true</code>
+     */
+    public boolean walkNextChild(ConditionalAndExpression node, Object resultOfPreviousChild, int indexOfNextChild);
+
+    /**
+     * This method is called before walking each child of the argument
+     * <code>node</code>. The return value of this method determines if
+     * the next child of the argument <code>node</code> should be walked.
+     * In case of returning <code>false</code>, none of the remaining
+     * children are walked. Instead, the node's leave method is called
+     * immediately. The argument <code>resultOfPreviousChild</code>
+     * holds the result of walking the previous child of the argument
+     * <code>node</code>. Usually, it is used to determine the return value
+     * of this method. The argument <code>indexOfNextChild</code>
+     * determines the index of the next child to be walked. This index
+     * determines the position in the children array of the argument <code>node</code>.
+     * Note: The index of the first child is 0.
+     * @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>false</code>, if no more childs should be walked, else <code>true</code>
+     */
+    public boolean walkNextChild(ConditionalOrExpression node, Object resultOfPreviousChild, int indexOfNextChild);
+
+    /**
+     * This method is called before walking each child of the argument
+     * <code>node</code>. The return value of this method determines if
+     * the next child of the argument <code>node</code> should be walked.
+     * In case of returning <code>false</code>, none of the remaining
+     * children are walked. Instead, the node's leave method is called
+     * immediately. The argument <code>resultOfPreviousChild</code>
+     * holds the result of walking the previous child of the argument
+     * <code>node</code>. Usually, it is used to determine the return value
+     * of this method. The argument <code>indexOfNextChild</code>
+     * determines the index of the next child to be walked. This index
+     * determines the position in the children array of the argument <code>node</code>.
+     * Note: The index of the first child is 0.
+     * @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>false</code>, if no more childs should be walked, else <code>true</code>
+     */
+    public boolean walkNextChild(ContainsCallExpression node, Object resultOfPreviousChild, int indexOfNextChild);
+
+    /**
+     * This method is called before walking each child of the argument
+     * <code>node</code>. The return value of this method determines if
+     * the next child of the argument <code>node</code> should be walked.
+     * In case of returning <code>false</code>, none of the remaining
+     * children are walked. Instead, the node's leave method is called
+     * immediately. The argument <code>resultOfPreviousChild</code>
+     * holds the result of walking the previous child of the argument
+     * <code>node</code>. Usually, it is used to determine the return value
+     * of this method. The argument <code>indexOfNextChild</code>
+     * determines the index of the next child to be walked. This index
+     * determines the position in the children array of the argument <code>node</code>.
+     * Note: The index of the first child is 0.
+     * @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>false</code>, if no more childs should be walked, else <code>true</code>
+     */
+    public boolean walkNextChild(DescendingOrderingExpression node, Object resultOfPreviousChild, int indexOfNextChild);
+
+    /**
+     * This method is called before walking each child of the argument
+     * <code>node</code>. The return value of this method determines if
+     * the next child of the argument <code>node</code> should be walked.
+     * In case of returning <code>false</code>, none of the remaining
+     * children are walked. Instead, the node's leave method is called
+     * immediately. The argument <code>resultOfPreviousChild</code>
+     * holds the result of walking the previous child of the argument
+     * <code>node</code>. Usually, it is used to determine the return value
+     * of this method. The argument <code>indexOfNextChild</code>
+     * determines the index of the next child to be walked. This index
+     * determines the position in the children array of the argument <code>node</code>.
+     * Note: The index of the first child is 0.
+     * @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>false</code>, if no more childs should be walked, else <code>true</code>
+     */
+    public boolean walkNextChild(DivideExpression node, Object resultOfPreviousChild, int indexOfNextChild);
+
+    /**
+     * This method is called before walking each child of the argument
+     * <code>node</code>. The return value of this method determines if
+     * the next child of the argument <code>node</code> should be walked.
+     * In case of returning <code>false</code>, none of the remaining
+     * children are walked. Instead, the node's leave method is called
+     * immediately. The argument <code>resultOfPreviousChild</code>
+     * holds the result of walking the previous child of the argument
+     * <code>node</code>. Usually, it is used to determine the return value
+     * of this method. The argument <code>indexOfNextChild</code>
+     * determines the index of the next child to be walked. This index
+     * determines the position in the children array of the argument <code>node</code>.
+     * Note: The index of the first child is 0.
+     * @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>false</code>, if no more childs should be walked, else <code>true</code>
+     */
+    public boolean walkNextChild(EqualsExpression node, Object resultOfPreviousChild, int indexOfNextChild);
+
+    /**
+     * This method is called before walking each child of the argument
+     * <code>node</code>. The return value of this method determines if
+     * the next child of the argument <code>node</code> should be walked.
+     * In case of returning <code>false</code>, none of the remaining
+     * children are walked. Instead, the node's leave method is called
+     * immediately. The argument <code>resultOfPreviousChild</code>
+     * holds the result of walking the previous child of the argument
+     * <code>node</code>. Usually, it is used to determine the return value
+     * of this method. The argument <code>indexOfNextChild</code>
+     * determines the index of the next child to be walked. This index
+     * determines the position in the children array of the argument <code>node</code>.
+     * Note: The index of the first child is 0.
+     * @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>false</code>, if no more childs should be walked, else <code>true</code>
+     */
+    public boolean walkNextChild(EndsWithCallExpression node, Object resultOfPreviousChild, int indexOfNextChild);
+
+    /**
+     * This method is called before walking each child of the argument
+     * <code>node</code>. The return value of this method determines if
+     * the next child of the argument <code>node</code> should be walked.
+     * In case of returning <code>false</code>, none of the remaining
+     * children are walked. Instead, the node's leave method is called
+     * immediately. The argument <code>resultOfPreviousChild</code>
+     * holds the result of walking the previous child of the argument
+     * <code>node</code>. Usually, it is used to determine the return value
+     * of this method. The argument <code>indexOfNextChild</code>
+     * determines the index of the next child to be walked. This index
+     * determines the position in the children array of the argument <code>node</code>.
+     * Note: The index of the first child is 0.
+     * @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>false</code>, if no more childs should be walked, else <code>true</code>
+     */
+    public boolean walkNextChild(FieldAccessExpression node, Object resultOfPreviousChild, int indexOfNextChild);
+
+    /**
+     * This method is called before walking each child of the argument
+     * <code>node</code>. The return value of this method determines if
+     * the next child of the argument <code>node</code> should be walked.
+     * In case of returning <code>false</code>, none of the remaining
+     * children are walked. Instead, the node's leave method is called
+     * immediately. The argument <code>resultOfPreviousChild</code>
+     * holds the result of walking the previous child of the argument
+     * <code>node</code>. Usually, it is used to determine the return value
+     * of this method. The argument <code>indexOfNextChild</code>
+     * determines the index of the next child to be walked. This index
+     * determines the position in the children array of the argument <code>node</code>.
+     * Note: The index of the first child is 0.
+     * @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>false</code>, if no more childs should be walked, else <code>true</code>
+     */
+    public boolean walkNextChild(GreaterThanEqualsExpression node, Object resultOfPreviousChild, int indexOfNextChild);
+
+    /**
+     * This method is called before walking each child of the argument
+     * <code>node</code>. The return value of this method determines if
+     * the next child of the argument <code>node</code> should be walked.
+     * In case of returning <code>false</code>, none of the remaining
+     * children are walked. Instead, the node's leave method is called
+     * immediately. The argument <code>resultOfPreviousChild</code>
+     * holds the result of walking the previous child of the argument
+     * <code>node</code>. Usually, it is used to determine the return value
+     * of this method. The argument <code>indexOfNextChild</code>
+     * determines the index of the next child to be walked. This index
+     * determines the position in the children array of the argument <code>node</code>.
+     * Note: The index of the first child is 0.
+     * @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>false</code>, if no more childs should be walked, else <code>true</code>
+     */
+    public boolean walkNextChild(GreaterThanExpression node, Object resultOfPreviousChild, int indexOfNextChild);
+
+    /**
+     * This method is called before walking each child of the argument
+     * <code>node</code>. The return value of this method determines if
+     * the next child of the argument <code>node</code> should be walked.
+     * In case of returning <code>false</code>, none of the remaining
+     * children are walked. Instead, the node's leave method is called
+     * immediately. The argument <code>resultOfPreviousChild</code>
+     * holds the result of walking the previous child of the argument
+     * <code>node</code>. Usually, it is used to determine the return value
+     * of this method. The argument <code>indexOfNextChild</code>
+     * determines the index of the next child to be walked. This index
+     * determines the position in the children array of the argument <code>node</code>.
+     * Note: The index of the first child is 0.
+     * @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>false</code>, if no more childs should be walked, else <code>true</code>
+     */
+    public boolean walkNextChild(IsEmptyCallExpression node, Object resultOfPreviousChild, int indexOfNextChild);
+
+    /**
+     * This method is called before walking each child of the argument
+     * <code>node</code>. The return value of this method determines if
+     * the next child of the argument <code>node</code> should be walked.
+     * In case of returning <code>false</code>, none of the remaining
+     * children are walked. Instead, the node's leave method is called
+     * immediately. The argument <code>resultOfPreviousChild</code>
+     * holds the result of walking the previous child of the argument
+     * <code>node</code>. Usually, it is used to determine the return value
+     * of this method. The argument <code>indexOfNextChild</code>
+     * determines the index of the next child to be walked. This index
+     * determines the position in the children array of the argument <code>node</code>.
+     * Note: The index of the first child is 0.
+     * @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>false</code>, if no more childs should be walked, else <code>true</code>
+     */
+    public boolean walkNextChild(LessThanEqualsExpression node, Object resultOfPreviousChild, int indexOfNextChild);
+
+    /**
+     * This method is called before walking each child of the argument
+     * <code>node</code>. The return value of this method determines if
+     * the next child of the argument <code>node</code> should be walked.
+     * In case of returning <code>false</code>, none of the remaining
+     * children are walked. Instead, the node's leave method is called
+     * immediately. The argument <code>resultOfPreviousChild</code>
+     * holds the result of walking the previous child of the argument
+     * <code>node</code>. Usually, it is used to determine the return value
+     * of this method. The argument <code>indexOfNextChild</code>
+     * determines the index of the next child to be walked. This index
+     * determines the position in the children array of the argument <code>node</code>.
+     * Note: The index of the first child is 0.
+     * @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>false</code>, if no more childs should be walked, else <code>true</code>
+     */
+    public boolean walkNextChild(LessThanExpression node, Object resultOfPreviousChild, int indexOfNextChild);
+
+    /**
+     * This method is called before walking each child of the argument
+     * <code>node</code>. The return value of this method determines if
+     * the next child of the argument <code>node</code> should be walked.
+     * In case of returning <code>false</code>, none of the remaining
+     * children are walked. Instead, the node's leave method is called
+     * immediately. The argument <code>resultOfPreviousChild</code>
+     * holds the result of walking the previous child of the argument
+     * <code>node</code>. Usually, it is used to determine the return value
+     * of this method. The argument <code>indexOfNextChild</code>
+     * determines the index of the next child to be walked. This index
+     * determines the position in the children array of the argument <code>node</code>.
+     * Note: The index of the first child is 0.
+     * @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>false</code>, if no more childs should be walked, else <code>true</code>
+     */
+    public boolean walkNextChild(MinusExpression node, Object resultOfPreviousChild, int indexOfNextChild);
+
+    /**
+     * This method is called before walking each child of the argument
+     * <code>node</code>. The return value of this method determines if
+     * the next child of the argument <code>node</code> should be walked.
+     * In case of returning <code>false</code>, none of the remaining
+     * children are walked. Instead, the node's leave method is called
+     * immediately. The argument <code>resultOfPreviousChild</code>
+     * holds the result of walking the previous child of the argument
+     * <code>node</code>. Usually, it is used to determine the return value
+     * of this method. The argument <code>indexOfNextChild</code>
+     * determines the index of the next child to be walked. This index
+     * determines the position in the children array of the argument <code>node</code>.
+     * Note: The index of the first child is 0.
+     * @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>false</code>, if no more childs should be walked, else <code>true</code>
+     */
+    public boolean walkNextChild(NotEqualsExpression node, Object resultOfPreviousChild, int indexOfNextChild);
+
+    /**
+     * This method is called before walking each child of the argument
+     * <code>node</code>. The return value of this method determines if
+     * the next child of the argument <code>node</code> should be walked.
+     * In case of returning <code>false</code>, none of the remaining
+     * children are walked. Instead, the node's leave method is called
+     * immediately. The argument <code>resultOfPreviousChild</code>
+     * holds the result of walking the previous child of the argument
+     * <code>node</code>. Usually, it is used to determine the return value
+     * of this method. The argument <code>indexOfNextChild</code>
+     * determines the index of the next child to be walked. This index
+     * determines the position in the children array of the argument <code>node</code>.
+     * Note: The index of the first child is 0.
+     * @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>false</code>, if no more childs should be walked, else <code>true</code>
+     */
+    public boolean walkNextChild(NotExpression node, Object resultOfPreviousChild, int indexOfNextChild);
+
+    /**
+     * This method is called before walking each child of the argument
+     * <code>node</code>. The return value of this method determines if
+     * the next child of the argument <code>node</code> should be walked.
+     * In case of returning <code>false</code>, none of the remaining
+     * children are walked. Instead, the node's leave method is called
+     * immediately. The argument <code>resultOfPreviousChild</code>
+     * holds the result of walking the previous child of the argument
+     * <code>node</code>. Usually, it is used to determine the return value
+     * of this method. The argument <code>indexOfNextChild</code>
+     * determines the index of the next child to be walked. This index
+     * determines the position in the children array of the argument <code>node</code>.
+     * Note: The index of the first child is 0.
+     * @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>false</code>, if no more childs should be walked, else <code>true</code>
+     */
+    public boolean walkNextChild(OrExpression node, Object resultOfPreviousChild, int indexOfNextChild);
+
+    /**
+     * This method is called before walking each child of the argument
+     * <code>node</code>. The return value of this method determines if
+     * the next child of the argument <code>node</code> should be walked.
+     * In case of returning <code>false</code>, none of the remaining
+     * children are walked. Instead, the node's leave method is called
+     * immediately. The argument <code>resultOfPreviousChild</code>
+     * holds the result of walking the previous child of the argument
+     * <code>node</code>. Usually, it is used to determine the return value
+     * of this method. The argument <code>indexOfNextChild</code>
+     * determines the index of the next child to be walked. This index
+     * determines the position in the children array of the argument <code>node</code>.
+     * Note: The index of the first child is 0.
+     * @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>false</code>, if no more childs should be walked, else <code>true</code>
+     */
+    public boolean walkNextChild(PlusExpression node, Object resultOfPreviousChild, int indexOfNextChild);
+
+    /**
+     * This method is called before walking each child of the argument
+     * <code>node</code>. The return value of this method determines if
+     * the next child of the argument <code>node</code> should be walked.
+     * In case of returning <code>false</code>, none of the remaining
+     * children are walked. Instead, the node's leave method is called
+     * immediately. The argument <code>resultOfPreviousChild</code>
+     * holds the result of walking the previous child of the argument
+     * <code>node</code>. Usually, it is used to determine the return value
+     * of this method. The argument <code>indexOfNextChild</code>
+     * determines the index of the next child to be walked. This index
+     * determines the position in the children array of the argument <code>node</code>.
+     * Note: The index of the first child is 0.
+     * @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>false</code>, if no more childs should be walked, else <code>true</code>
+     */
+    public boolean walkNextChild(QueryTree node, Object resultOfPreviousChild, int indexOfNextChild);
+
+    /**
+     * This method is called before walking each child of the argument
+     * <code>node</code>. The return value of this method determines if
+     * the next child of the argument <code>node</code> should be walked.
+     * In case of returning <code>false</code>, none of the remaining
+     * children are walked. Instead, the node's leave method is called
+     * immediately. The argument <code>resultOfPreviousChild</code>
+     * holds the result of walking the previous child of the argument
+     * <code>node</code>. Usually, it is used to determine the return value
+     * of this method. The argument <code>indexOfNextChild</code>
+     * determines the index of the next child to be walked. This index
+     * determines the position in the children array of the argument <code>node</code>.
+     * Note: The index of the first child is 0.
+     * @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>false</code>, if no more childs should be walked, else <code>true</code>
+     */
+    public boolean walkNextChild(StartsWithCallExpression node, Object resultOfPreviousChild, int indexOfNextChild);
+
+    /**
+     * This method is called before walking each child of the argument
+     * <code>node</code>. The return value of this method determines if
+     * the next child of the argument <code>node</code> should be walked.
+     * In case of returning <code>false</code>, none of the remaining
+     * children are walked. Instead, the node's leave method is called
+     * immediately. The argument <code>resultOfPreviousChild</code>
+     * holds the result of walking the previous child of the argument
+     * <code>node</code>. Usually, it is used to determine the return value
+     * of this method. The argument <code>indexOfNextChild</code>
+     * determines the index of the next child to be walked. This index
+     * determines the position in the children array of the argument <code>node</code>.
+     * Note: The index of the first child is 0.
+     * @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>false</code>, if no more childs should be walked, else <code>true</code>
+     */
+    public boolean walkNextChild(StaticFieldAccessExpression node, Object resultOfPreviousChild, int indexOfNextChild);
+
+    /**
+     * This method is called before walking each child of the argument
+     * <code>node</code>. The return value of this method determines if
+     * the next child of the argument <code>node</code> should be walked.
+     * In case of returning <code>false</code>, none of the remaining
+     * children are walked. Instead, the node's leave method is called
+     * immediately. The argument <code>resultOfPreviousChild</code>
+     * holds the result of walking the previous child of the argument
+     * <code>node</code>. Usually, it is used to determine the return value
+     * of this method. The argument <code>indexOfNextChild</code>
+     * determines the index of the next child to be walked. This index
+     * determines the position in the children array of the argument <code>node</code>.
+     * Note: The index of the first child is 0.
+     * @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>false</code>, if no more childs should be walked, else <code>true</code>
+     */
+    public boolean walkNextChild(TimesExpression node, Object resultOfPreviousChild, int indexOfNextChild);
+
+    /**
+     * This method is called before walking each child of the argument
+     * <code>node</code>. The return value of this method determines if
+     * the next child of the argument <code>node</code> should be walked.
+     * In case of returning <code>false</code>, none of the remaining
+     * children are walked. Instead, the node's leave method is called
+     * immediately. The argument <code>resultOfPreviousChild</code>
+     * holds the result of walking the previous child of the argument

[... 34 lines stripped ...]