Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/NodeVisitor.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/NodeVisitor.java?view=auto&rev=158176
==============================================================================
 incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/NodeVisitor.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/jdoql/tree/NodeVisitor.java Fri Mar 18 17:02:29 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/LICENSE2.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 ...]
