`arrive`

: This method is meant for initialization purposes
+ * and is called before walking a node's children.
+ * `leave`

: This method is meant for calculation purposes
+ * and is called after walking a node's children.
+ * `walkNextChild`

: 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. 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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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[] result=
s);
+
+ /**
+ * This method is called after walking the children of the argument
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. A node visitor instance uses this method
+ * to compute the result of walking the argument `node`

+ * and it's children. This result is returned by the tree walker's
+ * `walk`

method. The argument `results`

holds
+ * the results of walking the children of the argument ```
node.
+ * Usually, the result of the argument
````node`

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
+ * `node`

. The return value of this method determines if
+ * the next child of the argument `node`

should be walked.
+ * In case of returning `false`

, none of the remaining
+ * children are walked. Instead, the node's leave method is called
+ * immediately. The argument `resultOfPreviousChild`

+ * holds the result of walking the previous child of the argument
+ * `node`

. Usually, it is used to determine the return value
+ * of this method. The argument `indexOfNextChild`

+ * determines the index of the next child to be walked. This index
+ * determines the position in the children array of the argument `node`

.
+ * 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 previ=
ous child
+ * @param indexOfNextChild the index of the next child to be walked
+ * @return `false`

, if no more childs should be walked, els=
e `true`

+ */
+ public boolean walkNextChild(AndExpression node, Object resultOfPrevio=
usChild, int indexOfNextChild);
+
+ /**
+ * This method is called before walking each child of the argument
+ * `node`

. The return value of this method determines if
+ * the next child of the argument `node`

should be walked.
+ * In case of returning `false`

, none of the remaining
+ * children are walked. Instead, the node's leave method is called
+ * immediately. The argument `resultOfPreviousChild`

+ * holds the result of walking the previous child of the argument
+ * `node`

. Usually, it is used to determine the return value
+ * of this method. The argument `indexOfNextChild`

+ * determines the index of the next child to be walked. This index
+ * determines the position in the children array of the argument `node`

.
+ * 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 previ=
ous child
+ * @param indexOfNextChild the index of the next child to be walked
+ * @return `false`

, if no more childs should be walked, els=
e `true`

+ */
+ public boolean walkNextChild(AscendingOrderingExpression node, Object =
resultOfPreviousChild, int indexOfNextChild);
+
+ /**
+ * This method is called before walking each child of the argument
+ * `node`

. The return value of this method determines if
+ * the next child of the argument `node`

should be walked.
+ * In case of returning `false`

, none of the remaining
+ * children are walked. Instead, the node's leave method is called
+ * immediately. The argument `resultOfPreviousChild`

+ * holds the result of walking the previous child of the argument
+ * `node`

. Usually, it is used to determine the return value
+ * of this method. The argument `indexOfNextChild`

+ * determines the index of the next child to be walked. This index
+ * determines the position in the children array of the argument ```
node.
+ * 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 previ=
ous child
+ * @param indexOfNextChild the index of the next child to be walked
+ * @return
````false`

, if no more childs should be walked, els=
e `true`

+ */
+ public boolean walkNextChild(CastExpression node, Object resultOfPrevi=
ousChild, int indexOfNextChild);
+
+ /**
+ * This method is called before walking each child of the argument
+ * `node`

. The return value of this method determines if
+ * the next child of the argument `node`

should be walked.
+ * In case of returning `false`

, none of the remaining
+ * children are walked. Instead, the node's leave method is called
+ * immediately. The argument `resultOfPreviousChild`

+ * holds the result of walking the previous child of the argument
+ * `node`

. Usually, it is used to determine the return value
+ * of this method. The argument `indexOfNextChild`

+ * determines the index of the next child to be walked. This index
+ * determines the position in the children array of the argument ```
node.
+ * 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 previ=
ous child
+ * @param indexOfNextChild the index of the next child to be walked
+ * @return
````false`

, if no more childs should be walked, els=
e `true`

+ */
+ public boolean walkNextChild(ComplementExpression node, Object resultO=
fPreviousChild, int indexOfNextChild);
+
+ /**
+ * This method is called before walking each child of the argument
+ * `node`

. The return value of this method determines if
+ * the next child of the argument `node`

should be walked.
+ * In case of returning `false`

, none of the remaining
+ * children are walked. Instead, the node's leave method is called
+ * immediately. The argument `resultOfPreviousChild`

+ * holds the result of walking the previous child of the argument
+ * `node`

. Usually, it is used to determine the return value
+ * of this method. The argument `indexOfNextChild`

+ * determines the index of the next child to be walked. This index
+ * determines the position in the children array of the argument ```
node.
+ * 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 previ=
ous child
+ * @param indexOfNextChild the index of the next child to be walked
+ * @return
````false`

, if no more childs should be walked, els=
e `true`

+ */
+ public boolean walkNextChild(ConditionalAndExpression node, Object res=
ultOfPreviousChild, int indexOfNextChild);
+
+ /**
+ * This method is called before walking each child of the argument
+ * `node`

. The return value of this method determines if
+ * the next child of the argument `node`

should be walked.
+ * In case of returning `false`

, none of the remaining
+ * children are walked. Instead, the node's leave method is called
+ * immediately. The argument `resultOfPreviousChild`

+ * holds the result of walking the previous child of the argument
+ * `node`

. Usually, it is used to determine the return value
+ * of this method. The argument `indexOfNextChild`

+ * determines the index of the next child to be walked. This index
+ * determines the position in the children array of the argument ```
node.
+ * 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 previ=
ous child
+ * @param indexOfNextChild the index of the next child to be walked
+ * @return
````false`

, if no more childs should be walked, els=
e `true`

+ */
+ public boolean walkNextChild(ConditionalOrExpression node, Object resu=
ltOfPreviousChild, int indexOfNextChild);
+
+ /**
+ * This method is called before walking each child of the argument
+ * `node`

. The return value of this method determines if
+ * the next child of the argument `node`

should be walked.
+ * In case of returning `false`

, none of the remaining
+ * children are walked. Instead, the node's leave method is called
+ * immediately. The argument `resultOfPreviousChild`

+ * holds the result of walking the previous child of the argument
+ * `node`

. Usually, it is used to determine the return value
+ * of this method. The argument `indexOfNextChild`

+ * determines the index of the next child to be walked. This index
+ * determines the position in the children array of the argument ```
node.
+ * 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 previ=
ous child
+ * @param indexOfNextChild the index of the next child to be walked
+ * @return
````false`

, if no more childs should be walked, els=
e `true`

+ */
+ public boolean walkNextChild(ContainsCallExpression node, Object resul=
tOfPreviousChild, int indexOfNextChild);
+
+ /**
+ * This method is called before walking each child of the argument
+ * `node`

. The return value of this method determines if
+ * the next child of the argument `node`

should be walked.
+ * In case of returning `false`

, none of the remaining
+ * children are walked. Instead, the node's leave method is called
+ * immediately. The argument `resultOfPreviousChild`

+ * holds the result of walking the previous child of the argument
+ * `node`

. Usually, it is used to determine the return value
+ * of this method. The argument `indexOfNextChild`

+ * determines the index of the next child to be walked. This index
+ * determines the position in the children array of the argument ```
node.
+ * 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 previ=
ous child
+ * @param indexOfNextChild the index of the next child to be walked
+ * @return
````false`

, if no more childs should be walked, els=
e `true`

+ */
+ public boolean walkNextChild(DescendingOrderingExpression node, Object=
resultOfPreviousChild, int indexOfNextChild);
+
+ /**
+ * This method is called before walking each child of the argument
+ * `node`

. The return value of this method determines if
+ * the next child of the argument `node`

should be walked.
+ * In case of returning `false`

, none of the remaining
+ * children are walked. Instead, the node's leave method is called
+ * immediately. The argument `resultOfPreviousChild`

+ * holds the result of walking the previous child of the argument
+ * `node`

. Usually, it is used to determine the return value
+ * of this method. The argument `indexOfNextChild`

+ * determines the index of the next child to be walked. This index
+ * determines the position in the children array of the argument ```
node.
+ * 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 previ=
ous child
+ * @param indexOfNextChild the index of the next child to be walked
+ * @return
````false`

, if no more childs should be walked, els=
e `true`

+ */
+ public boolean walkNextChild(DivideExpression node, Object resultOfPre=
viousChild, int indexOfNextChild);
+
+ /**
+ * This method is called before walking each child of the argument
+ * `node`

. The return value of this method determines if
+ * the next child of the argument `node`

should be walked.
+ * In case of returning `false`

, none of the remaining
+ * children are walked. Instead, the node's leave method is called
+ * immediately. The argument `resultOfPreviousChild`

+ * holds the result of walking the previous child of the argument
+ * `node`

. Usually, it is used to determine the return value
+ * of this method. The argument `indexOfNextChild`

+ * determines the index of the next child to be walked. This index
+ * determines the position in the children array of the argument ```
node.
+ * 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 previ=
ous child
+ * @param indexOfNextChild the index of the next child to be walked
+ * @return
````false`

, if no more childs should be walked, els=
e `true`

+ */
+ public boolean walkNextChild(EqualsExpression node, Object resultOfPre=
viousChild, int indexOfNextChild);
+
+ /**
+ * This method is called before walking each child of the argument
+ * `node`

. The return value of this method determines if
+ * the next child of the argument `node`

should be walked.
+ * In case of returning `false`

, none of the remaining
+ * children are walked. Instead, the node's leave method is called
+ * immediately. The argument `resultOfPreviousChild`

+ * holds the result of walking the previous child of the argument
+ * `node`

. Usually, it is used to determine the return value
+ * of this method. The argument `indexOfNextChild`

+ * determines the index of the next child to be walked. This index
+ * determines the position in the children array of the argument ```
node.
+ * 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 previ=
ous child
+ * @param indexOfNextChild the index of the next child to be walked
+ * @return
````false`

, if no more childs should be walked, els=
e `true`

+ */
+ public boolean walkNextChild(EndsWithCallExpression node, Object resul=
tOfPreviousChild, int indexOfNextChild);
+
+ /**
+ * This method is called before walking each child of the argument
+ * `node`

. The return value of this method determines if
+ * the next child of the argument `node`

should be walked.
+ * In case of returning `false`

, none of the remaining
+ * children are walked. Instead, the node's leave method is called
+ * immediately. The argument `resultOfPreviousChild`

+ * holds the result of walking the previous child of the argument
+ * `node`

. Usually, it is used to determine the return value
+ * of this method. The argument `indexOfNextChild`

+ * determines the index of the next child to be walked. This index
+ * determines the position in the children array of the argument ```
node.
+ * 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 previ=
ous child
+ * @param indexOfNextChild the index of the next child to be walked
+ * @return
````false`

, if no more childs should be walked, els=
e `true`

+ */
+ public boolean walkNextChild(FieldAccessExpression node, Object result=
OfPreviousChild, int indexOfNextChild);
+
+ /**
+ * This method is called before walking each child of the argument
+ * `node`

. The return value of this method determines if
+ * the next child of the argument `node`

should be walked.
+ * In case of returning `false`

, none of the remaining
+ * children are walked. Instead, the node's leave method is called
+ * immediately. The argument `resultOfPreviousChild`

+ * holds the result of walking the previous child of the argument
+ * `node`

. Usually, it is used to determine the return value
+ * of this method. The argument `indexOfNextChild`

+ * determines the index of the next child to be walked. This index
+ * determines the position in the children array of the argument ```
node.
+ * 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 previ=
ous child
+ * @param indexOfNextChild the index of the next child to be walked
+ * @return
````false`

, if no more childs should be walked, els=
e `true`

+ */
+ public boolean walkNextChild(GreaterThanEqualsExpression node, Object =
resultOfPreviousChild, int indexOfNextChild);
+
+ /**
+ * This method is called before walking each child of the argument
+ * `node`

. The return value of this method determines if
+ * the next child of the argument `node`

should be walked.
+ * In case of returning `false`

, none of the remaining
+ * children are walked. Instead, the node's leave method is called
+ * immediately. The argument `resultOfPreviousChild`

+ * holds the result of walking the previous child of the argument
+ * `node`

. Usually, it is used to determine the return value
+ * of this method. The argument `indexOfNextChild`

+ * determines the index of the next child to be walked. This index
+ * determines the position in the children array of the argument ```
node.
+ * 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 previ=
ous child
+ * @param indexOfNextChild the index of the next child to be walked
+ * @return
````false`

, if no more childs should be walked, els=
e `true`

+ */
+ public boolean walkNextChild(GreaterThanExpression node, Object result=
OfPreviousChild, int indexOfNextChild);
+
+ /**
+ * This method is called before walking each child of the argument
+ * `node`

. The return value of this method determines if
+ * the next child of the argument `node`

should be walked.
+ * In case of returning `false`

, none of the remaining
+ * children are walked. Instead, the node's leave method is called
+ * immediately. The argument `resultOfPreviousChild`

+ * holds the result of walking the previous child of the argument
+ * `node`

. Usually, it is used to determine the return value
+ * of this method. The argument `indexOfNextChild`

+ * determines the index of the next child to be walked. This index
+ * determines the position in the children array of the argument ```
node.
+ * 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 previ=
ous child
+ * @param indexOfNextChild the index of the next child to be walked
+ * @return
````false`

, if no more childs should be walked, els=
e `true`

+ */
+ public boolean walkNextChild(IsEmptyCallExpression node, Object result=
OfPreviousChild, int indexOfNextChild);
+
+ /**
+ * This method is called before walking each child of the argument
+ * `node`

. The return value of this method determines if
+ * the next child of the argument `node`

should be walked.
+ * In case of returning `false`

, none of the remaining
+ * children are walked. Instead, the node's leave method is called
+ * immediately. The argument `resultOfPreviousChild`

+ * holds the result of walking the previous child of the argument
+ * `node`

. Usually, it is used to determine the return value
+ * of this method. The argument `indexOfNextChild`

+ * determines the index of the next child to be walked. This index
+ * determines the position in the children array of the argument ```
node.
+ * 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 previ=
ous child
+ * @param indexOfNextChild the index of the next child to be walked
+ * @return
````false`

, if no more childs should be walked, els=
e `true`

+ */
+ public boolean walkNextChild(LessThanEqualsExpression node, Object res=
ultOfPreviousChild, int indexOfNextChild);
+
+ /**
+ * This method is called before walking each child of the argument
+ * `node`

. The return value of this method determines if
+ * the next child of the argument `node`

should be walked.
+ * In case of returning `false`

, none of the remaining
+ * children are walked. Instead, the node's leave method is called
+ * immediately. The argument `resultOfPreviousChild`

+ * holds the result of walking the previous child of the argument
+ * `node`

. Usually, it is used to determine the return value
+ * of this method. The argument `indexOfNextChild`

+ * determines the index of the next child to be walked. This index
+ * determines the position in the children array of the argument ```
node.
+ * 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 previ=
ous child
+ * @param indexOfNextChild the index of the next child to be walked
+ * @return
````false`

, if no more childs should be walked, els=
e `true`

+ */
+ public boolean walkNextChild(LessThanExpression node, Object resultOfP=
reviousChild, int indexOfNextChild);
+
+ /**
+ * This method is called before walking each child of the argument
+ * `node`

. The return value of this method determines if
+ * the next child of the argument `node`

should be walked.
+ * In case of returning `false`

, none of the remaining
+ * children are walked. Instead, the node's leave method is called
+ * immediately. The argument `resultOfPreviousChild`

+ * holds the result of walking the previous child of the argument
+ * `node`

. Usually, it is used to determine the return value
+ * of this method. The argument `indexOfNextChild`

+ * determines the index of the next child to be walked. This index
+ * determines the position in the children array of the argument ```
node.
+ * 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 previ=
ous child
+ * @param indexOfNextChild the index of the next child to be walked
+ * @return
````false`

, if no more childs should be walked, els=
e `true`

+ */
+ public boolean walkNextChild(MinusExpression node, Object resultOfPrev=
iousChild, int indexOfNextChild);
+
+ /**
+ * This method is called before walking each child of the argument
+ * `node`

. The return value of this method determines if
+ * the next child of the argument `node`

should be walked.
+ * In case of returning `false`

, none of the remaining
+ * children are walked. Instead, the node's leave method is called
+ * immediately. The argument `resultOfPreviousChild`

+ * holds the result of walking the previous child of the argument
+ * `node`

. Usually, it is used to determine the return value
+ * of this method. The argument `indexOfNextChild`

+ * determines the index of the next child to be walked. This index
+ * determines the position in the children array of the argument ```
node.
+ * 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 previ=
ous child
+ * @param indexOfNextChild the index of the next child to be walked
+ * @return
````false`

, if no more childs should be walked, els=
e `true`

+ */
+ public boolean walkNextChild(NotEqualsExpression node, Object resultOf=
PreviousChild, int indexOfNextChild);
+
+ /**
+ * This method is called before walking each child of the argument
+ * `node`

. The return value of this method determines if
+ * the next child of the argument `node`

should be walked.
+ * In case of returning `false`

, none of the remaining
+ * children are walked. Instead, the node's leave method is called
+ * immediately. The argument `resultOfPreviousChild`

+ * holds the result of walking the previous child of the argument
+ * `node`

. Usually, it is used to determine the return value
+ * of this method. The argument `indexOfNextChild`

+ * determines the index of the next child to be walked. This index
+ * determines the position in the children array of the argument ```
node.
+ * 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 previ=
ous child
+ * @param indexOfNextChild the index of the next child to be walked
+ * @return
````false`

, if no more childs should be walked, els=
e `true`

+ */
+ public boolean walkNextChild(NotExpression node, Object resultOfPrevio=
usChild, int indexOfNextChild);
+
+ /**
+ * This method is called before walking each child of the argument
+ * `node`

. The return value of this method determines if
+ * the next child of the argument `node`

should be walked.
+ * In case of returning `false`

, none of the remaining
+ * children are walked. Instead, the node's leave method is called
+ * immediately. The argument `resultOfPreviousChild`

+ * holds the result of walking the previous child of the argument
+ * `node`

. Usually, it is used to determine the return value
+ * of this method. The argument `indexOfNextChild`

+ * determines the index of the next child to be walked. This index
+ * determines the position in the children array of the argument ```
node.
+ * 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 previ=
ous child
+ * @param indexOfNextChild the index of the next child to be walked
+ * @return
````false`

, if no more childs should be walked, els=
e `true`

+ */
+ public boolean walkNextChild(OrExpression node, Object resultOfPreviou=
sChild, int indexOfNextChild);
+
+ /**
+ * This method is called before walking each child of the argument
+ * `node`

. The return value of this method determines if
+ * the next child of the argument `node`

should be walked.
+ * In case of returning `false`

, none of the remaining
+ * children are walked. Instead, the node's leave method is called
+ * immediately. The argument `resultOfPreviousChild`

+ * holds the result of walking the previous child of the argument
+ * `node`

. Usually, it is used to determine the return value
+ * of this method. The argument `indexOfNextChild`

+ * determines the index of the next child to be walked. This index
+ * determines the position in the children array of the argument ```
node.
+ * 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 previ=
ous child
+ * @param indexOfNextChild the index of the next child to be walked
+ * @return
````false`

, if no more childs should be walked, els=
e `true`

+ */
+ public boolean walkNextChild(PlusExpression node, Object resultOfPrevi=
ousChild, int indexOfNextChild);
+
+ /**
+ * This method is called before walking each child of the argument
+ * `node`

. The return value of this method determines if
+ * the next child of the argument `node`

should be walked.
+ * In case of returning `false`

, none of the remaining
+ * children are walked. Instead, the node's leave method is called
+ * immediately. The argument `resultOfPreviousChild`

+ * holds the result of walking the previous child of the argument
+ * `node`

. Usually, it is used to determine the return value
+ * of this method. The argument `indexOfNextChild`

+ * determines the index of the next child to be walked. This index
+ * determines the position in the children array of the argument ```
node.
+ * 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 previ=
ous child
+ * @param indexOfNextChild the index of the next child to be walked
+ * @return
````false`

, if no more childs should be walked, els=
e `true`

+ */
+ public boolean walkNextChild(QueryTree node, Object resultOfPreviousCh=
ild, int indexOfNextChild);
+
+ /**
+ * This method is called before walking each child of the argument
+ * `node`

. The return value of this method determines if
+ * the next child of the argument `node`

should be walked.
+ * In case of returning `false`

, none of the remaining
+ * children are walked. Instead, the node's leave method is called
+ * immediately. The argument `resultOfPreviousChild`

+ * holds the result of walking the previous child of the argument
+ * `node`

. Usually, it is used to determine the return value
+ * of this method. The argument `indexOfNextChild`

+ * determines the index of the next child to be walked. This index
+ * determines the position in the children array of the argument ```
node.
+ * 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 previ=
ous child
+ * @param indexOfNextChild the index of the next child to be walked
+ * @return
````false`

, if no more childs should be walked, els=
e `true`

+ */
+ public boolean walkNextChild(StartsWithCallExpression node, Object res=
ultOfPreviousChild, int indexOfNextChild);
+
+ /**
+ * This method is called before walking each child of the argument
+ * `node`

. The return value of this method determines if
+ * the next child of the argument `node`

should be walked.
+ * In case of returning `false`

, none of the remaining
+ * children are walked. Instead, the node's leave method is called
+ * immediately. The argument `resultOfPreviousChild`

+ * holds the result of walking the previous child of the argument
+ * `node`

. Usually, it is used to determine the return value
+ * of this method. The argument `indexOfNextChild`

+ * determines the index of the next child to be walked. This index
+ * determines the position in the children array of the argument ```
node.
+ * 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 previ=
ous child
+ * @param indexOfNextChild the index of the next child to be walked
+ * @return
````false`

, if no more childs should be walked, els=
e `true`

+ */
+ public boolean walkNextChild(StaticFieldAccessExpression node, Object =
resultOfPreviousChild, int indexOfNextChild);
+
+ /**
+ * This method is called before walking each child of the argument
+ * `node`

. The return value of this method determines if
+ * the next child of the argument `node`

should be walked.
+ * In case of returning `false`

, none of the remaining
+ * children are walked. Instead, the node's leave method is called
+ * immediately. The argument `resultOfPreviousChild`

+ * holds the result of walking the previous child of the argument
+ * `node`

. Usually, it is used to determine the return value
+ * of this method. The argument `indexOfNextChild`

+ * determines the index of the next child to be walked. This index
+ * determines the position in the children array of the argument ```
node.
+ * 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 previ=
ous child
+ * @param indexOfNextChild the index of the next child to be walked
+ * @return
````false`

, if no more childs should be walked, els=
e `true`

+ */
+ public boolean walkNextChild(TimesExpression node, Object resultOfPrev=
iousChild, int indexOfNextChild);
+
+ /**
+ * This method is called before walking each child of the argument
+ * `node`

. The return value of this method determines if
+ * the next child of the argument `node`

should be walked.
+ * In case of returning `false`

, none of the remaining
+ * children are walked. Instead, the node's leave method is called
+ * immediately. The argument `resultOfPreviousChild`

+ * holds the result of walking the previous child of the argument
[=2E.. 34 lines stripped ...]