db-jdo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From m..@apache.org
Subject svn commit: r171353 [10/13] - in /incubator/jdo/trunk/query20: ./ src/ src/conf/ src/java/ src/java/org/ src/java/org/apache/ src/java/org/apache/jdo/ src/java/org/apache/jdo/impl/ src/java/org/apache/jdo/impl/jdoql/ src/java/org/apache/jdo/impl/jdoql/jdoqlc/ src/java/org/apache/jdo/impl/jdoql/scope/ src/java/org/apache/jdo/impl/jdoql/tree/ src/java/org/apache/jdo/jdoql/ src/java/org/apache/jdo/jdoql/tree/
Date Sun, 22 May 2005 18:09:00 GMT
Added: incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/AbstractNodeVisitor.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/AbstractNodeVisitor.java?rev=171353&view=auto
==============================================================================
--- incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/AbstractNodeVisitor.java (added)
+++ incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/AbstractNodeVisitor.java Sun May 22 11:08:57 2005
@@ -0,0 +1,1586 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at 
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * See the License for the specific language governing permissions and 
+ * limitations under the License.
+ */
+
+package org.apache.jdo.jdoql.tree;
+
+/**
+ * This class provides a default implementation for the node visitor pattern.
+ * Methods having derived nodes as arguments delegate to those methods
+ * having least derived nodes as arguments. As some visitors do not need
+ * to know each specific operations,
+ * they do not need to provide code for those operations.
+ * In addition to methods defined in the interface <code>NodeVisitor</code>
+ * this class defines protected methods taking non-leaf nodes in terms of the
+ * node hierarchy of interfaces.
+ *
+ * @author Michael Watzek
+ */
+public abstract class AbstractNodeVisitor implements NodeVisitor
+{
+    //protected methods
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>Expression</code>.
+     * @param node the node to be walked
+     */
+    protected void arrive(BinaryExpression node)
+    {   arrive( (Expression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>Node</code>.
+     * @param node the node to be walked
+     */
+    protected void arrive(Declaration node)
+    {   arrive( (Node) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>Node</code>.
+     * @param node the node to be walked
+     */
+    protected void arrive(Expression node)
+    {   arrive( (Node) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>Expression</code>.
+     * @param node the node to be walked
+     */
+    protected void arrive(MethodCallExpression node)
+    {   arrive( (Expression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>Node</code>.
+     * @param node the node to be walked
+     */
+    protected void arrive(OrderingExpression node)
+    {   arrive( (Node) node );
+    }
+
+    /**
+     * This method defines the default implementation for all
+     * <code>arrive</code> methods: It immediately returns without executing
+     * any other instruction.
+     * @param node the node to be walked
+     */
+    protected void arrive(Node node)
+    {   return;
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>Expression</code>.
+     * @param node the node to be walked
+     */
+    protected void arrive(UnaryExpression node)
+    {   arrive( (Expression) node );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>Expression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    protected Object leave(BinaryExpression node, Object[] results)
+    {   return leave( (Expression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>Node</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    protected Object leave(Declaration node, Object[] results)
+    {   return leave( (Node) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>Node</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    protected Object leave(Expression node, Object[] results)
+    {   return leave( (Node) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>Expression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    protected Object leave(MethodCallExpression node, Object[] results)
+    {   return leave( (Expression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>Node</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    protected Object leave(OrderingExpression node, Object[] results)
+    {   return leave( (Node) node, results );
+    }
+
+    /**
+     * This method defines the default implementation for all
+     * <code>leave</code> methods: It immediately returns <code>null</code>
+     * without executing any other instruction.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return <code>null</code>
+     */
+    protected Object leave(Node node, Object[] results)
+    {   return null;
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>Expression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    protected Object leave(UnaryExpression node, Object[] results)
+    {   return leave( (Expression) node, results );
+    }
+
+
+    /**
+     * This method delegates to <code>walkNextChild</code> casting the argument
+     * <code>node</code> to <code>Expression</code>. It returns the value
+     * of that method.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return the result of the delegation call
+     */
+    protected boolean walkNextChild(BinaryExpression node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return walkNextChild( (Expression) node, resultOfPreviousChild, indexOfNextChild );
+    }
+
+    /**
+     * This method delegates to <code>walkNextChild</code> casting the argument
+     * <code>node</code> to <code>Node</code>. It returns the value
+     * of that method.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return the result of the delegation call
+     */
+    protected boolean walkNextChild(Expression node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return walkNextChild( (Node) node, resultOfPreviousChild, indexOfNextChild );
+    }
+
+    /**
+     * This method delegates to <code>walkNextChild</code> casting the argument
+     * <code>node</code> to <code>Expression</code>. It returns the value
+     * of that method.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return the result of the delegation call
+     */
+    protected boolean walkNextChild(IdentifierExpression node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return walkNextChild( (Expression) node, resultOfPreviousChild, indexOfNextChild );
+    }
+
+    /**
+     * This method delegates to <code>walkNextChild</code> casting the argument
+     * <code>node</code> to <code>Expression</code>. It returns the value
+     * of that method.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return the result of the delegation call
+     */
+    protected boolean walkNextChild(MethodCallExpression node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return walkNextChild( (Expression) node, resultOfPreviousChild, indexOfNextChild );
+    }
+
+    /**
+     * This method defines the default implementation for all
+     * <code>walkNextChild</code> methods: It immediately returns <code>true</code>
+     * without executing any other instruction.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return <code>true</code>
+     */
+    protected boolean walkNextChild(Node node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return true;
+    }
+
+    /**
+     * This method delegates to <code>walkNextChild</code> casting the argument
+     * <code>node</code> to <code>Node</code>. It returns the value
+     * of that method.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return the result of the delegation call
+     */
+    protected boolean walkNextChild(OrderingExpression node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return walkNextChild( (Node) node, resultOfPreviousChild, indexOfNextChild );
+    }
+
+    /**
+     * This method delegates to <code>walkNextChild</code> casting the argument
+     * <code>node</code> to <code>Expression</code>. It returns the value
+     * of that method.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return the result of the delegation call
+     */
+    protected boolean walkNextChild(UnaryExpression node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return walkNextChild( (Expression) node, resultOfPreviousChild, indexOfNextChild );
+    }
+
+    //public methods
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(AndExpression node)
+    {   arrive( (BinaryExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>OrderingExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(AscendingOrderingExpression node)
+    {   arrive( (OrderingExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>ConstantExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(BooleanLiteralExpression node)
+    {   arrive( (ConstantExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>ConstantExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(ByteLiteralExpression node)
+    {   arrive( (ConstantExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>Node</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(CandidateClass node)
+    {   arrive( (Node) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>Expression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(CastExpression node)
+    {   arrive( (Expression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>ConstantExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(CharLiteralExpression node)
+    {   arrive( (ConstantExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>UnaryExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(ComplementExpression node)
+    {   arrive( (UnaryExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(ConditionalAndExpression node)
+    {   arrive( (BinaryExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(ConditionalOrExpression node)
+    {   arrive( (BinaryExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>Expression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(ConstantExpression node)
+    {   arrive( (Expression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>MethodCallExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(ContainsCallExpression node)
+    {   arrive( (MethodCallExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>OrderingExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(DescendingOrderingExpression node)
+    {   arrive( (OrderingExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(DivideExpression node)
+    {   arrive( (BinaryExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>ConstantExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(DoubleLiteralExpression node)
+    {   arrive( (ConstantExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(EqualsExpression node)
+    {   arrive( (BinaryExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>MethodCallExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(EndsWithCallExpression node)
+    {   arrive( (MethodCallExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>IdentifierExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(FieldAccessExpression node)
+    {   arrive( (IdentifierExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>ConstantExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(FloatLiteralExpression node)
+    {   arrive( (ConstantExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(GreaterThanEqualsExpression node)
+    {   arrive( (BinaryExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(GreaterThanExpression node)
+    {   arrive( (BinaryExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>Expression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(IdentifierExpression node)
+    {   arrive( (Expression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>ConstantExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(IntLiteralExpression node)
+    {   arrive( (ConstantExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>MethodCallExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(IsEmptyCallExpression node)
+    {   arrive( (MethodCallExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(LessThanEqualsExpression node)
+    {   arrive( (BinaryExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(LessThanExpression node)
+    {   arrive( (BinaryExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>ConstantExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(LongLiteralExpression node)
+    {   arrive( (ConstantExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(MinusExpression node)
+    {   arrive( (BinaryExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(NotEqualsExpression node)
+    {   arrive( (BinaryExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>UnaryExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(NotExpression node)
+    {   arrive( (UnaryExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(OrExpression node)
+    {   arrive( (BinaryExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>IdentifierExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(ParameterAccessExpression node)
+    {   arrive( (IdentifierExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>Declaration</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(ParameterDeclaration node)
+    {   arrive( (Declaration) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(PlusExpression node)
+    {   arrive( (BinaryExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>Node</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(QueryTree node)
+    {   arrive( (Node) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>ConstantExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(ShortLiteralExpression node)
+    {   arrive( (ConstantExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>MethodCallExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(StartsWithCallExpression node)
+    {   arrive( (MethodCallExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>FieldAccessExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(StaticFieldAccessExpression node)
+    {   arrive( (FieldAccessExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>IdentifierExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(ThisExpression node)
+    {   arrive( (IdentifierExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(TimesExpression node)
+    {   arrive( (BinaryExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>Node</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(Type node)
+    {   arrive( (Node) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>UnaryExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(UnaryMinusExpression node)
+    {   arrive( (UnaryExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>UnaryExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(UnaryPlusExpression node)
+    {   arrive( (UnaryExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>IdentifierExpression</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(VariableAccessExpression node)
+    {   arrive( (IdentifierExpression) node );
+    }
+
+    /**
+     * This method delegates to <code>arrive</code> casting the argument
+     * <code>node</code> to <code>Declaration</code>.
+     * @param node the node to be walked
+     */
+    public void arrive(VariableDeclaration node)
+    {   arrive( (Declaration) node );
+    }
+
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(AndExpression node, Object[] results)
+    {   return leave( (BinaryExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>OrderingExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(AscendingOrderingExpression node, Object[] results)
+    {   return leave( (OrderingExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>ConstantExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(BooleanLiteralExpression node, Object[] results)
+    {   return leave( (ConstantExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>ConstantExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(ByteLiteralExpression node, Object[] results)
+    {   return leave( (ConstantExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>Node</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(CandidateClass node, Object[] results)
+    {   return leave( (Node) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>Expression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(CastExpression node, Object[] results)
+    {   return leave( (Expression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>ConstantExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(CharLiteralExpression node, Object[] results)
+    {   return leave( (ConstantExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>UnaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(ComplementExpression node, Object[] results)
+    {   return leave( (UnaryExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(ConditionalAndExpression node, Object[] results)
+    {   return leave( (BinaryExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(ConditionalOrExpression node, Object[] results)
+    {   return leave( (BinaryExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>Expression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(ConstantExpression node, Object[] results)
+    {   return leave( (Expression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>MethodCallExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(ContainsCallExpression node, Object[] results)
+    {   return leave( (MethodCallExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>OrderingExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(DescendingOrderingExpression node, Object[] results)
+    {   return leave( (OrderingExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(DivideExpression node, Object[] results)
+    {   return leave( (BinaryExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>ConstantExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(DoubleLiteralExpression node, Object[] results)
+    {   return leave( (ConstantExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>MethodCallExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(EndsWithCallExpression node, Object[] results)
+    {   return leave( (MethodCallExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(EqualsExpression node, Object[] results)
+    {   return leave( (BinaryExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>IdentifierExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(FieldAccessExpression node, Object[] results)
+    {   return leave( (IdentifierExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>ConstantExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(FloatLiteralExpression node, Object[] results)
+    {   return leave( (ConstantExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(GreaterThanEqualsExpression node, Object[] results)
+    {   return leave( (BinaryExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(GreaterThanExpression node, Object[] results)
+    {   return leave( (BinaryExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>Expression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(IdentifierExpression node, Object[] results)
+    {   return leave( (Expression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>ConstantExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(IntLiteralExpression node, Object[] results)
+    {   return leave( (ConstantExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>MethodCallExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(IsEmptyCallExpression node, Object[] results)
+    {   return leave( (MethodCallExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(LessThanEqualsExpression node, Object[] results)
+    {   return leave( (BinaryExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(LessThanExpression node, Object[] results)
+    {   return leave( (BinaryExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>ConstantExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(LongLiteralExpression node, Object[] results)
+    {   return leave( (ConstantExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(MinusExpression node, Object[] results)
+    {   return leave( (BinaryExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(NotEqualsExpression node, Object[] results)
+    {   return leave( (BinaryExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>UnaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(NotExpression node, Object[] results)
+    {   return leave( (UnaryExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(OrExpression node, Object[] results)
+    {   return leave( (BinaryExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>IdentifierExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(ParameterAccessExpression node, Object[] results)
+    {   return leave( (IdentifierExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>Declaration</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(ParameterDeclaration node, Object[] results)
+    {   return leave( (Declaration) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(PlusExpression node, Object[] results)
+    {   return leave( (BinaryExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>Node</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(QueryTree node, Object[] results)
+    {   return leave( (Node) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>ConstantExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(ShortLiteralExpression node, Object[] results)
+    {   return leave( (ConstantExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>MethodCallExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(StartsWithCallExpression node, Object[] results)
+    {   return leave( (MethodCallExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>FieldAccessExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(StaticFieldAccessExpression node, Object[] results)
+    {   return leave( (FieldAccessExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>IdentifierExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(ThisExpression node, Object[] results)
+    {   return leave( (IdentifierExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(TimesExpression node, Object[] results)
+    {   return leave( (BinaryExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>Node</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(Type node, Object[] results)
+    {   return leave( (Node) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>UnaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(UnaryMinusExpression node, Object[] results)
+    {   return leave( (UnaryExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>UnaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(UnaryPlusExpression node, Object[] results)
+    {   return leave( (UnaryExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>IdentifierExpression</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(VariableAccessExpression node, Object[] results)
+    {   return leave( (IdentifierExpression) node, results );
+    }
+
+    /**
+     * This method delegates to <code>leave</code> casting the argument
+     * <code>node</code> to <code>Declaration</code>. It returns the value
+     * of that method.
+     * @param node the node having been walked
+     * @param results the results of walking the node's children
+     * @return the result of the delegation call
+     */
+    public Object leave(VariableDeclaration node, Object[] results)
+    {   return leave( (Declaration) node, results );
+    }
+
+    /**
+     * This method delegates to <code>walkNextChild</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return the result of the delegation call
+     */
+    public boolean walkNextChild(AndExpression node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return walkNextChild( (BinaryExpression) node, resultOfPreviousChild, indexOfNextChild );
+    }
+
+    /**
+     * This method delegates to <code>walkNextChild</code> casting the argument
+     * <code>node</code> to <code>OrderingExpression</code>. It returns the value
+     * of that method.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return the result of the delegation call
+     */
+    public boolean walkNextChild(AscendingOrderingExpression node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return walkNextChild( (OrderingExpression) node, resultOfPreviousChild, indexOfNextChild );
+    }
+
+    /**
+     * This method delegates to <code>walkNextChild</code> casting the argument
+     * <code>node</code> to <code>Expression</code>. It returns the value
+     * of that method.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return the result of the delegation call
+     */
+    public boolean walkNextChild(CastExpression node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return walkNextChild( (Expression) node, resultOfPreviousChild, indexOfNextChild );
+    }
+
+    /**
+     * This method delegates to <code>walkNextChild</code> casting the argument
+     * <code>node</code> to <code>UnaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return the result of the delegation call
+     */
+    public boolean walkNextChild(ComplementExpression node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return walkNextChild( (UnaryExpression) node, resultOfPreviousChild, indexOfNextChild );
+    }
+
+    /**
+     * This method delegates to <code>walkNextChild</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return the result of the delegation call
+     */
+    public boolean walkNextChild(ConditionalAndExpression node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return walkNextChild( (BinaryExpression) node, resultOfPreviousChild, indexOfNextChild );
+    }
+
+    /**
+     * This method delegates to <code>walkNextChild</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return the result of the delegation call
+     */
+    public boolean walkNextChild(ConditionalOrExpression node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return walkNextChild( (BinaryExpression) node, resultOfPreviousChild, indexOfNextChild );
+    }
+
+    /**
+     * This method delegates to <code>walkNextChild</code> casting the argument
+     * <code>node</code> to <code>MethodCallExpression</code>. It returns the value
+     * of that method.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return the result of the delegation call
+     */
+    public boolean walkNextChild(ContainsCallExpression node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return walkNextChild( (MethodCallExpression) node, resultOfPreviousChild, indexOfNextChild );
+    }
+
+    /**
+     * This method delegates to <code>walkNextChild</code> casting the argument
+     * <code>node</code> to <code>OrderingExpression</code>. It returns the value
+     * of that method.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return the result of the delegation call
+     */
+    public boolean walkNextChild(DescendingOrderingExpression node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return walkNextChild( (OrderingExpression) node, resultOfPreviousChild, indexOfNextChild );
+    }
+
+    /**
+     * This method delegates to <code>walkNextChild</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return the result of the delegation call
+     */
+    public boolean walkNextChild(DivideExpression node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return walkNextChild( (BinaryExpression) node, resultOfPreviousChild, indexOfNextChild );
+    }
+
+    /**
+     * This method delegates to <code>walkNextChild</code> casting the argument
+     * <code>node</code> to <code>MethodCallExpression</code>. It returns the value
+     * of that method.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return the result of the delegation call
+     */
+    public boolean walkNextChild(EndsWithCallExpression node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return walkNextChild( (MethodCallExpression) node, resultOfPreviousChild, indexOfNextChild );
+    }
+
+    /**
+     * This method delegates to <code>walkNextChild</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return the result of the delegation call
+     */
+    public boolean walkNextChild(EqualsExpression node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return walkNextChild( (BinaryExpression) node, resultOfPreviousChild, indexOfNextChild );
+    }
+
+    /**
+     * This method delegates to <code>walkNextChild</code> casting the argument
+     * <code>node</code> to <code>IdentifierExpression</code>. It returns the value
+     * of that method.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return the result of the delegation call
+     */
+    public boolean walkNextChild(FieldAccessExpression node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return walkNextChild( (IdentifierExpression) node, resultOfPreviousChild, indexOfNextChild );
+    }
+
+    /**
+     * This method delegates to <code>walkNextChild</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return the result of the delegation call
+     */
+    public boolean walkNextChild(GreaterThanEqualsExpression node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return walkNextChild( (BinaryExpression) node, resultOfPreviousChild, indexOfNextChild );
+    }
+
+    /**
+     * This method delegates to <code>walkNextChild</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return the result of the delegation call
+     */
+    public boolean walkNextChild(GreaterThanExpression node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return walkNextChild( (BinaryExpression) node, resultOfPreviousChild, indexOfNextChild );
+    }
+
+    /**
+     * This method delegates to <code>walkNextChild</code> casting the argument
+     * <code>node</code> to <code>MethodCallExpression</code>. It returns the value
+     * of that method.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return the result of the delegation call
+     */
+    public boolean walkNextChild(IsEmptyCallExpression node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return walkNextChild( (MethodCallExpression) node, resultOfPreviousChild, indexOfNextChild );
+    }
+
+    /**
+     * This method delegates to <code>walkNextChild</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return the result of the delegation call
+     */
+    public boolean walkNextChild(LessThanEqualsExpression node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return walkNextChild( (BinaryExpression) node, resultOfPreviousChild, indexOfNextChild );
+    }
+
+    /**
+     * This method delegates to <code>walkNextChild</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return the result of the delegation call
+     */
+    public boolean walkNextChild(LessThanExpression node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return walkNextChild( (BinaryExpression) node, resultOfPreviousChild, indexOfNextChild );
+    }
+
+    /**
+     * This method delegates to <code>walkNextChild</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return the result of the delegation call
+     */
+    public boolean walkNextChild(MinusExpression node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return walkNextChild( (BinaryExpression) node, resultOfPreviousChild, indexOfNextChild );
+    }
+
+    /**
+     * This method delegates to <code>walkNextChild</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return the result of the delegation call
+     */
+    public boolean walkNextChild(NotEqualsExpression node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return walkNextChild( (BinaryExpression) node, resultOfPreviousChild, indexOfNextChild );
+    }
+
+    /**
+     * This method delegates to <code>walkNextChild</code> casting the argument
+     * <code>node</code> to <code>UnaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return the result of the delegation call
+     */
+    public boolean walkNextChild(NotExpression node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return walkNextChild( (UnaryExpression) node, resultOfPreviousChild, indexOfNextChild );
+    }
+
+    /**
+     * This method delegates to <code>walkNextChild</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return the result of the delegation call
+     */
+    public boolean walkNextChild(OrExpression node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return walkNextChild( (BinaryExpression) node, resultOfPreviousChild, indexOfNextChild );
+    }
+
+    /**
+     * This method delegates to <code>walkNextChild</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return the result of the delegation call
+     */
+    public boolean walkNextChild(PlusExpression node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return walkNextChild( (BinaryExpression) node, resultOfPreviousChild, indexOfNextChild );
+    }
+
+    /**
+     * This method delegates to <code>walkNextChild</code> casting the argument
+     * <code>node</code> to <code>Node</code>. It returns the value
+     * of that method.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return the result of the delegation call
+     */
+    public boolean walkNextChild(QueryTree node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return walkNextChild( (Node) node, resultOfPreviousChild, indexOfNextChild );
+    }
+
+    /**
+     * This method delegates to <code>walkNextChild</code> casting the argument
+     * <code>node</code> to <code>MethodCallExpression</code>. It returns the value
+     * of that method.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return the result of the delegation call
+     */
+    public boolean walkNextChild(StartsWithCallExpression node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return walkNextChild( (MethodCallExpression) node, resultOfPreviousChild, indexOfNextChild );
+    }
+
+    /**
+     * This method delegates to <code>walkNextChild</code> casting the argument
+     * <code>node</code> to <code>FieldAccessExpression</code>. It returns the value
+     * of that method.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return the result of the delegation call
+     */
+    public boolean walkNextChild(StaticFieldAccessExpression node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return walkNextChild( (FieldAccessExpression) node, resultOfPreviousChild, indexOfNextChild );
+    }
+
+    /**
+     * This method delegates to <code>walkNextChild</code> casting the argument
+     * <code>node</code> to <code>BinaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return the result of the delegation call
+     */
+    public boolean walkNextChild(TimesExpression node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return walkNextChild( (BinaryExpression) node, resultOfPreviousChild, indexOfNextChild );
+    }
+
+    /**
+     * This method delegates to <code>walkNextChild</code> casting the argument
+     * <code>node</code> to <code>UnaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return the result of the delegation call
+     */
+    public boolean walkNextChild(UnaryMinusExpression node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return walkNextChild( (UnaryExpression) node, resultOfPreviousChild, indexOfNextChild );
+    }
+
+    /**
+     * This method delegates to <code>walkNextChild</code> casting the argument
+     * <code>node</code> to <code>UnaryExpression</code>. It returns the value
+     * of that method.
+     * @param node the parent node of the children currently walked
+     * @param resultOfPreviousChild the result of walking the node's previous child
+     * @param indexOfNextChild the index of the next child to be walked
+     * @return the result of the delegation call
+     */
+    public boolean walkNextChild(UnaryPlusExpression node, Object resultOfPreviousChild, int indexOfNextChild)
+    {   return walkNextChild( (UnaryExpression) node, resultOfPreviousChild, indexOfNextChild );
+    }
+}

Added: incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/AndExpression.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/AndExpression.java?rev=171353&view=auto
==============================================================================
--- incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/AndExpression.java (added)
+++ incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/AndExpression.java Sun May 22 11:08:57 2005
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at 
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * See the License for the specific language governing permissions and 
+ * limitations under the License.
+ */
+
+package org.apache.jdo.jdoql.tree;
+
+/**
+ * This node represents a bitwise or logical and operator depending on the result
+ * types of its children. A bitwise operator is based on arithmetical types.
+ * In contrast, a logical operator is based on boolean types.
+ * The string representation of this operator is <code>&</code>.
+ *
+ * @author Michael Watzek
+ */
+public interface AndExpression extends BinaryExpression
+{
+}

Added: incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/AscendingOrderingExpression.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/AscendingOrderingExpression.java?rev=171353&view=auto
==============================================================================
--- incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/AscendingOrderingExpression.java (added)
+++ incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/AscendingOrderingExpression.java Sun May 22 11:08:57 2005
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at 
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * See the License for the specific language governing permissions and 
+ * limitations under the License.
+ */
+
+package org.apache.jdo.jdoql.tree;
+
+/**
+ * This node represents an operator defining ascendent ordering of instances
+ * returned by a query execution. The order is determined by an expression
+ * such as <code>FieldAccessExpression</code>. This expression is this node's
+ * child.
+ *
+ * @author Michael Watzek
+ */
+public interface AscendingOrderingExpression extends OrderingExpression
+{
+}

Added: incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/BinaryExpression.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/BinaryExpression.java?rev=171353&view=auto
==============================================================================
--- incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/BinaryExpression.java (added)
+++ incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/BinaryExpression.java Sun May 22 11:08:57 2005
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at 
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * See the License for the specific language governing permissions and 
+ * limitations under the License.
+ */
+
+package org.apache.jdo.jdoql.tree;
+
+/**
+ * This node expression represents a binary operator. All binary operators have exactly
+ * two children. Examples of binary operators
+ * are <code>AndExpression</code> and <code>EqualsExpression</code>.
+ *
+ * @author Michael Watzek
+ */
+public interface BinaryExpression extends Expression
+{
+    /**
+     * Returns the first child of this node.
+     * @return the first child
+     */
+    public Expression getLeftExpression();
+
+    /**
+     * Returns the second child of this node.
+     * @return the second child
+     */
+    public Expression getRightExpression();
+
+    /**
+     * Returns the class instance suiteable for implementing the result
+     * of this expression. In case of integral binary expressions
+     * that class instance is also the result type of the operation retrieved
+     * by method <code>getJavaClass</code>. In case of relational binary
+     * expressions, that class instance differs from the type retrieved by
+     * <code>getJavaClass</code>, because relational binary expressions
+     * have a boolean result type which does not depend of the operand types.
+     * @return the common operand type
+     */
+    public Class getCommonOperandType();
+}
+

Added: incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/BooleanLiteralExpression.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/BooleanLiteralExpression.java?rev=171353&view=auto
==============================================================================
--- incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/BooleanLiteralExpression.java (added)
+++ incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/BooleanLiteralExpression.java Sun May 22 11:08:57 2005
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at 
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * See the License for the specific language governing permissions and 
+ * limitations under the License.
+ */
+
+package org.apache.jdo.jdoql.tree;
+
+/**
+ * This node represents a boolean literal such as <code>true</code> or
+ * <code>false</code>. It does not have any children.
+ *
+ * @author Michael Watzek
+ */
+public interface BooleanLiteralExpression extends ConstantExpression
+{
+    /**
+     * Returns the boolean value represented by this expression.
+     * @return the boolean value
+     */
+    public boolean getBoolean();
+}

Added: incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/ByteLiteralExpression.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/ByteLiteralExpression.java?rev=171353&view=auto
==============================================================================
--- incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/ByteLiteralExpression.java (added)
+++ incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/ByteLiteralExpression.java Sun May 22 11:08:57 2005
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at 
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * See the License for the specific language governing permissions and 
+ * limitations under the License.
+ */
+
+package org.apache.jdo.jdoql.tree;
+
+/**
+ * This node represents a byte literal. It does not have any children.
+ *
+ * @author Michael Watzek
+ */
+public interface ByteLiteralExpression extends ConstantExpression
+{
+    /**
+     * Returns the byte value represented by this expression.
+     * @return the byte value
+     */
+    public byte getByte();
+}
\ No newline at end of file

Added: incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/CandidateClass.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/CandidateClass.java?rev=171353&view=auto
==============================================================================
--- incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/CandidateClass.java (added)
+++ incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/CandidateClass.java Sun May 22 11:08:57 2005
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at 
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * See the License for the specific language governing permissions and 
+ * limitations under the License.
+ */
+
+package org.apache.jdo.jdoql.tree;
+
+/**
+ * This node represents the candidate class of a query.
+ * The candidate class defines the type of instances in the
+ * candidate collection on which the filter expression is applied.
+ * This node does not have nay children.
+ *
+ * @author Michael Watzek
+ */
+public interface CandidateClass extends Node
+{
+}

Added: incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/CastExpression.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/CastExpression.java?rev=171353&view=auto
==============================================================================
--- incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/CastExpression.java (added)
+++ incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/CastExpression.java Sun May 22 11:08:57 2005
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at 
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * See the License for the specific language governing permissions and 
+ * limitations under the License.
+ */
+
+package org.apache.jdo.jdoql.tree;
+
+/**
+ * This node represents a cast expression. It has a result type and a child
+ * which corresponds with the expression to cast.
+ *
+ * @author Michael Watzek
+ */
+public interface CastExpression extends Expression
+{
+    /**
+     * Returns the string representation of the Java class,
+     * to which this node's expression is casted.
+     * @return the Java type name
+     */
+    public String getTypeName();
+
+    /**
+     * Returns the node's cast expression.
+     * @return the node's cast expression
+     */
+    public Expression getExpression();
+}

Added: incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/CharLiteralExpression.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/CharLiteralExpression.java?rev=171353&view=auto
==============================================================================
--- incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/CharLiteralExpression.java (added)
+++ incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/CharLiteralExpression.java Sun May 22 11:08:57 2005
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at 
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * See the License for the specific language governing permissions and 
+ * limitations under the License.
+ */
+
+package org.apache.jdo.jdoql.tree;
+
+/**
+ * This node represents a character literal. It does not have any children.
+ *
+ * @author Michael Watzek
+ */
+public interface CharLiteralExpression extends ConstantExpression
+{
+    /**
+     * Returns the char value represented by this expression.
+     * @return the char value
+     */
+    public char getChar();
+}
\ No newline at end of file

Added: incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/ComplementExpression.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/ComplementExpression.java?rev=171353&view=auto
==============================================================================
--- incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/ComplementExpression.java (added)
+++ incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/ComplementExpression.java Sun May 22 11:08:57 2005
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at 
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * See the License for the specific language governing permissions and 
+ * limitations under the License.
+ */
+
+package org.apache.jdo.jdoql.tree;
+
+/**
+ * This node represents a bitwise not operator.
+ * A bitwise not operator is a unary expression.
+ * The string representation of this operator is <code>~</code>.
+ *
+ * @author Michael Watzek
+ */
+public interface ComplementExpression extends UnaryExpression
+{
+}

Added: incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/ConditionalAndExpression.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/ConditionalAndExpression.java?rev=171353&view=auto
==============================================================================
--- incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/ConditionalAndExpression.java (added)
+++ incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/ConditionalAndExpression.java Sun May 22 11:08:57 2005
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at 
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * See the License for the specific language governing permissions and 
+ * limitations under the License.
+ */
+
+package org.apache.jdo.jdoql.tree;
+
+/**
+ * This node represents a conditional and operator.
+ * A conditional and operator is a binary expression.
+ * The string representation of this operator is <code>&&</code>.
+ *
+ * @author Michael Watzek
+ */
+public interface ConditionalAndExpression extends BinaryExpression
+{
+}

Added: incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/ConditionalOrExpression.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/ConditionalOrExpression.java?rev=171353&view=auto
==============================================================================
--- incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/ConditionalOrExpression.java (added)
+++ incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/ConditionalOrExpression.java Sun May 22 11:08:57 2005
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at 
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * See the License for the specific language governing permissions and 
+ * limitations under the License.
+ */
+
+package org.apache.jdo.jdoql.tree;
+
+/**
+ * This node represents a conditional or operator.
+ * A conditional or operator is a binary expression.
+ * The string representation of this operator is <code>||</code>.
+ *
+ * @author Michael Watzek
+ */
+public interface ConditionalOrExpression extends BinaryExpression
+{
+}

Added: incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/ConstantExpression.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/ConstantExpression.java?rev=171353&view=auto
==============================================================================
--- incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/ConstantExpression.java (added)
+++ incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/ConstantExpression.java Sun May 22 11:08:57 2005
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at 
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * See the License for the specific language governing permissions and 
+ * limitations under the License.
+ */
+
+package org.apache.jdo.jdoql.tree;
+
+/**
+ * This node represents a constant expression.
+ * Examples of constant expressions are <code>BooleanLiteralExpression</code> or
+ * <code>ByteLiteralExpression</code>. It does not have any children.
+ *
+ * @author Michael Watzek
+ */
+public interface ConstantExpression extends Expression
+{
+    /**
+     * Returns the value represented by this expression.
+     * @return the value
+     */
+    public Object getValue();
+}

Added: incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/ContainsCallExpression.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/ContainsCallExpression.java?rev=171353&view=auto
==============================================================================
--- incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/ContainsCallExpression.java (added)
+++ incubator/jdo/trunk/query20/src/java/org/apache/jdo/jdoql/tree/ContainsCallExpression.java Sun May 22 11:08:57 2005
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at 
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * See the License for the specific language governing permissions and 
+ * limitations under the License.
+ */
+
+package org.apache.jdo.jdoql.tree;
+
+/**
+ * This node represents the method call expression
+ * <code>Collection.contains</code>. Children of this node are a target
+ * expression (e.g. a <code>FieldAccessExpression</code>) and the method
+ * argument which is an arbitrary expression.
+ *
+ * @author Michael Watzek
+ */
+public interface ContainsCallExpression extends MethodCallExpression
+{
+}



Mime
View raw message