Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/jdoql/tree/Tree.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/jdoql/tree/Tree.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/jdoql/tree/Tree.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/jdoql/tree/Tree.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,1021 @@
+/*
+ * 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.impl.jdoql.tree;
+
+import antlr.collections.AST;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.LinkedList;
+import java.util.Map;
+
+import org.apache.jdo.impl.jdoql.jdoqlc.JDOQLTokenTypes;
+import org.apache.jdo.jdoql.JDOQueryException;
+import org.apache.jdo.jdoql.tree.AndExpression;
+import org.apache.jdo.jdoql.tree.CandidateClass;
+import org.apache.jdo.jdoql.tree.CastExpression;
+import org.apache.jdo.jdoql.tree.ComplementExpression;
+import org.apache.jdo.jdoql.tree.ConditionalAndExpression;
+import org.apache.jdo.jdoql.tree.ConditionalOrExpression;
+import org.apache.jdo.jdoql.tree.ConstantExpression;
+import org.apache.jdo.jdoql.tree.Declaration;
+import org.apache.jdo.jdoql.tree.DivideExpression;
+import org.apache.jdo.jdoql.tree.EqualsExpression;
+import org.apache.jdo.jdoql.tree.Expression;
+import org.apache.jdo.jdoql.tree.ExpressionFactory;
+import org.apache.jdo.jdoql.tree.FieldAccessExpression;
+import org.apache.jdo.jdoql.tree.GreaterThanEqualsExpression;
+import org.apache.jdo.jdoql.tree.GreaterThanExpression;
+import org.apache.jdo.jdoql.tree.IdentifierExpression;
+import org.apache.jdo.jdoql.tree.LessThanEqualsExpression;
+import org.apache.jdo.jdoql.tree.LessThanExpression;
+import org.apache.jdo.jdoql.tree.MethodCallExpression;
+import org.apache.jdo.jdoql.tree.MinusExpression;
+import org.apache.jdo.jdoql.tree.Node;
+import org.apache.jdo.jdoql.tree.NodeVisitor;
+import org.apache.jdo.jdoql.tree.NotEqualsExpression;
+import org.apache.jdo.jdoql.tree.NotExpression;
+import org.apache.jdo.jdoql.tree.OrExpression;
+import org.apache.jdo.jdoql.tree.ParameterDeclaration;
+import org.apache.jdo.jdoql.tree.PlusExpression;
+import org.apache.jdo.jdoql.tree.QueryTree;
+import org.apache.jdo.jdoql.tree.StaticFieldAccessExpression;
+import org.apache.jdo.jdoql.tree.TimesExpression;
+import org.apache.jdo.jdoql.tree.UnaryMinusExpression;
+import org.apache.jdo.jdoql.tree.UnaryPlusExpression;
+import org.apache.jdo.jdoql.tree.VariableDeclaration;
+
+
+/**
+ * This node represents the root of a query tree.
+ * You can use it to factorize this node's children, as there are
+ * candidate class, declarations, filter expression and
+ * ordering expressions.
+ *
+ * @author Michael Watzek
+ */
+public final class Tree extends NodeImpl implements QueryTree, ExpressionFactory
+{
+ static final JavaKeyWords javaKeyWords = new JavaKeyWords();
+
+ CandidateClass candidateClass;
+ Map parameterMap;
+ List parameterList;
+ Map variableMap;
+ List orderings;
+ Expression filter;
+
+ String serializedCandidateClassName; // serialization support
+
+ /**
+ * The noarg constructor is called by persistence manager internal.
+ */
+ public Tree()
+ { super( JDOQLTokenTypes.QUERY_TREE, "QueryTree", null ); //NOI18N
+ init();
+ }
+
+ /**
+ * This constructor is called by semantic analysis only.
+ * @param candidateClass the candidate class
+ * @param parameterDeclarations the antlr node containing all
+ * parameter declaration nodes as siblings
+ * @param variableDeclarations the antlr node containing all
+ * variable declaration nodes as siblings
+ * @param orderingExpressions the antlr node containing all
+ * ordering nodes as siblings
+ * @param filter the filter expression
+ */
+ public Tree(CandidateClass candidateClass,
+ ParameterDecl parameterDeclarations,
+ VariableDecl variableDeclarations,
+ OrderingExpr orderingExpressions,
+ Expr filter)
+ { this();
+ Class clazz = candidateClass.getJavaClass();
+ this.clazz = clazz;
+ this.candidateClass = candidateClass;
+ for( ParameterDecl current=parameterDeclarations; current!=null; current = (ParameterDecl)current.getNextSibling() )
+ { this.parameterMap.put( current.getName(), current );
+ this.parameterList.add( current );
+ }
+ for( VariableDecl current=variableDeclarations; current!=null; current = (VariableDecl)current.getNextSibling() )
+ this.variableMap.put( current.getName(), current );
+ for( OrderingExpr current=orderingExpressions; current!=null; current = (OrderingExpr)current.getNextSibling() )
+ this.orderings.add( current );
+ this.filter = filter;
+ initANTLRAST();
+ }
+
+ /**
+ * Creates and returns a copy of this object.
+ * @return the copy
+ * @exception CloneNotSupportedException thrown by <code>super.clone()</code>
+ */
+ protected Object clone() throws CloneNotSupportedException
+ { Tree copy = (Tree) super.clone();
+ init();
+ return copy;
+ }
+
+ /**
+ * Sets the candidate class for this query tree.
+ * This method throws <code>NullPointerException</code> if the argument
+ * <code>clazz</code> is <code>null</code>.
+ * Otherwise this method invalidates this tree:
+ * Parameters, variables, orderings and the filter are nullified.
+ * @param clazz the candidate class
+ * @exception <code>NullPointerException</code> if the argument <code>clazz</code> is null
+ */
+ public void setCandidateClass(Class clazz)
+ { if( clazz==null )
+ throw new NullPointerException();
+ if( this.clazz!=null )
+ reset();
+ this.clazz = clazz;
+ this.candidateClass = new CandidateClassImpl( new TypeImpl(clazz) );
+ }
+
+ /**
+ * Declares a parameter for this query tree.
+ * This method throws <code>NullPointerException</code> if one of the arguments
+ * <code>type</code> or <code>parameter</code> are <code>null</code>.
+ * If a parameter is already declared having the same name
+ * as the argument <code>parameter</code>, then that declaration is
+ * replaced by this declaration.
+ * Once you have declared a parameter, you can access it using method
+ * <code>newIdentifier</code>.
+ * Please note: You can not declare a parameter and a variable having the same name.
+ * @param clazz the instance of a Java class which is the type of the declared parameter
+ * @param parameter the name of the declared parameter
+ * @exception NullPointerException if type or parameter are null
+ * @exception JDOQueryException if a variable has been declared with the same name
+ */
+ public void declareParameter(Class clazz, String parameter)
+ { if( clazz==null ||
+ parameter==null )
+ throw new NullPointerException();
+ if( this.variableMap.get(parameter)!=null )
+ throw new JDOQueryException( msg.msg("EXC_ParameterVariableCollision", parameter) ); //NOI18N
+ ParameterDeclaration decl = new ParameterDecl( new TypeImpl(clazz), parameter );
+ this.parameterMap.put( parameter, decl );
+ this.parameterList.add( decl );
+ }
+
+ /**
+ * Declares a variable for this query tree.
+ * This method throws <code>NullPointerException</code> if one of the arguments
+ * <code>type</code> or <code>variable</code> are <code>null</code>.
+ * If a variable is already declared having the same name
+ * as the argument <code>variable</code>, then that declaration is
+ * replaced by this declaration.
+ * Once you have declared a variable, you can access it using method
+ * <code>newIdentifier</code>.
+ * Please note: You can not declare a parameter and a variable having the same name.
+ * @param clazz the instance of a Java class which is the type of the declared variable
+ * @param variable the name of the declared variable
+ * @exception NullPointerException if type or variable are null
+ * @exception JDOQueryException if a parameter has been declared with the same name
+ */
+ public void declareVariable(Class clazz, String variable)
+ { if( clazz==null ||
+ variable==null )
+ throw new NullPointerException();
+ if( this.parameterMap.get(variable)!=null )
+ throw new JDOQueryException( msg.msg("EXC_VariableParameterCollision", variable) ); //NOI18N
+ VariableDeclaration decl = new VariableDecl( new TypeImpl(clazz), variable );
+ this.variableMap.put( variable, decl );
+ }
+
+ /**
+ * Adds an ascending ordering expression to this query tree.
+ * This method throws <code>NullPointerException</code> if the argument
+ * <code>expression</code> is <code>null</code>.
+ * The order of adding ascending and descending ordering expressions defines
+ * the order of instances in the result collection of an executed query
+ * instance corresponding with this query tree.
+ * @param expression the order expression
+ * @exception NullPointerException if expression is null
+ */
+ public void addAscendingOrdering(Expression expression)
+ { if( expression==null )
+ throw new NullPointerException();
+ this.orderings.add( new AscendingOrderingExpr(expression) );
+ }
+
+ /**
+ * Adds an descending ordering expression to this query tree.
+ * This method throws <code>NullPointerException</code> if the argument
+ * <code>expression</code> is <code>null</code>.
+ * The order of adding ascending and descending ordering expressions defines
+ * the order of instances in the result collection of an executed query
+ * instance corresponding with this query tree.
+ * @param expression the order expression
+ * @exception NullPointerException if expression is null
+ */
+ public void addDescendingOrdering(Expression expression)
+ { if( expression==null )
+ throw new NullPointerException();
+ this.orderings.add( new DescendingOrderingExpr(expression) );
+ }
+
+ /**
+ * Sets the filter expression for this query tree.
+ * This method throws <code>NullPointerException</code> if the argument
+ * <code>filter</code> is <code>null</code>.
+ * @param filter the filter expression
+ * @exception NullPointerException if filter is null
+ * @exception JDOQueryException if the result type of filter is a non boolean type
+ */
+ public void setFilter(Expression filter)
+ { if( filter==null )
+ throw new NullPointerException();
+ if( filter.getJavaClass()!=Boolean.class &&
+ filter.getJavaClass()!=boolean.class )
+ throw new JDOQueryException( msg.msg("EXC_IllegalTypeForFilterExpression", filter) ); //NOI18N
+ this.filter = filter;
+ }
+
+ /**
+ * Returns the candidate class.
+ * @return the candidate class
+ */
+ public Class getCandidateClass()
+ { if( this.candidateClass==null )
+ throw new JDOQueryException( msg.msg("EXC_MissingCandidateClass") ); //NOI18N
+ return this.candidateClass.getJavaClass();
+ }
+
+ /**
+ * Returns a map containing all declared variables.
+ * This map contains variable names as keys and instances of
+ * <code>VariableDeclaration</code> as values.
+ * @return the map of declared variables
+ */
+ public Map getDeclaredVariables()
+ { return this.variableMap;
+ }
+
+ /**
+ * Returns a map containing all declared parameters.
+ * This map contains parameter names as keys and instances of
+ * <code>ParameterDeclaration</code> as values.
+ * @return the map of declared parameters
+ */
+ public Map getDeclaredParameters()
+ { return this.parameterMap;
+ }
+
+ /**
+ * Returns a list of all declared parameters. The order of entries is
+ * defined by the order of calls <code>declareParameter</code>.
+ * This list contains instances of
+ * <code>ParametersDeclaration</code> as entries.
+ * @return the list of declared parameters
+ */
+ public List getDeclaredParametersAsList()
+ { return this.parameterList;
+ }
+
+ /**
+ * Returns the filter expression of this query tree.
+ * @return the filter or null.
+ */
+ public Expression getFilter()
+ { return (Expression) this.filter;
+ }
+
+ /**
+ * Returns a list of all added ordering expressions.
+ * The order of entries is defined by the order of calls
+ * <code>addAscendingOrdering</code> and <code>addDescendingOrdering</code>.
+ * This list contains instances of
+ * <code>OrderingExpression</code> as entries.
+ * @return the list of declared parameters
+ */
+ public List getOrderingExpressions()
+ { return this.orderings;
+ }
+
+ /**
+ * Returns an instance of either <code>ThisExpression</code> or
+ * <code>VariableAccessExpression</code> or
+ * <code>ParameterAccessExpression</code> or <code>FieldAccessExpression</code>
+ * depending on the fact which of the classes the argument
+ * <code>identifier</code> maps to.
+ * This method throws <code>NullPointerException</code> if the argument
+ * <code>identifier</code> is <code>null</code> or the candidate class is not set.
+ * Note: If you pass <code>"this"</code> as an identifier name, then
+ * an instance of <code>ThisExpression</code> is returned. If you pass any
+ * other java key word as an identifier name, then an instance of
+ * <code>JDOQueryException</code> is thrown.
+ * @param identifier the name of the identifier access expression
+ * @return the specialized identifier access expression instance
+ * @exception NullPointerException if identifier is null
+ * @exception JDOQueryException if identifier is a java key word.
+ */
+ public IdentifierExpression newIdentifier(String identifier)
+ { if( identifier==null )
+ throw new NullPointerException();
+ IdentifierExpression identifierExpr;
+ if( identifier.equals("this") ) //NOI18N
+ identifierExpr = new ThisExpr( this.candidateClass==null?null:this.candidateClass.getJavaClass() );
+ else
+ { if( javaKeyWords.isJavaKeyWord(identifier) )
+ throw new JDOQueryException( msg.msg("EXC_IllegalIdentifier", identifier) ); //NOI18N
+ Declaration decl = (Declaration) this.variableMap.get( identifier );
+ if( decl==null )
+ { decl = (Declaration) this.parameterMap.get( identifier );
+ if( decl==null )
+ //identifierExpr = new FieldAccessExpr( new ThisExpr(this.candidateClass.getJavaClass()), identifier );
+ identifierExpr = new IdentifierExpr( JDOQLTokenTypes.IDENT, identifier, null );
+ else
+ identifierExpr = new ParameterAccessExpr( decl.getJavaClass(), identifier );
+ }
+ else
+ identifierExpr = new VariableAccessExpr( decl.getJavaClass(), identifier );
+ }
+ return identifierExpr;
+ }
+
+ /**
+ * Returns an instance of <code>FieldAccessExpression</code>.
+ * This method throws <code>NullPointerException</code> if one of the arguments
+ * <code>target</code> or <code>fieldName</code> are <code>null</code>.
+ * @param target the target expression of the field access expression
+ * @param fieldName the name of the field to access
+ * @return the field access expression instance
+ * @exception NullPointerException if target or fieldName are null
+ */
+ public FieldAccessExpression newFieldAccess(Expression target, String fieldName)
+ { if( target==null ||
+ fieldName==null )
+ throw new NullPointerException();
+ return new FieldAccessExpr( target, fieldName );
+ }
+
+ /**
+ * Returns an instance of <code>StaticFieldAccessExpression</code>.
+ * This method throws <code>NullPointerException</code> if one of the arguments
+ * <code>clazz</code> or <code>fieldName</code> are <code>null</code>.
+ * @param clazz the class instance defining the field
+ * @param fieldName the name of the field to access
+ * @return the static field access expression instance
+ * @exception NullPointerException if clazz or fieldName are null
+ */
+ public StaticFieldAccessExpression newFieldAccess(Class clazz, String fieldName)
+ { if( clazz==null ||
+ fieldName==null )
+ throw new NullPointerException();
+ return new StaticFieldAccessExpr( new TypeImpl(clazz), fieldName );
+ }
+
+ /**
+ * Returns an instance of <code>MethodCallExpression</code>.
+ * Note: If the method corresponding with methodName does not have any
+ * arguments, then the argument <code>arguments</code> is ignored.
+ * This method throws <code>NullPointerException</code> if one of the arguments
+ * <code>target</code> or <code>methodName</code>
+ * are <code>null</code>.
+ * @param target the target expression of the method call expression
+ * @param methodName the name of the method
+ * @param arguments the array of arguments
+ * @return the specialized method call expression
+ * @exception NullPointerException if target or methodName are null
+ * @exception JDOQueryException if methodName is not one of
+ * <code>"contains"</code>, <code>"endsWith"</code>, <code>"isEmpty"</code>
+ * or <code>"startsWith"</code>.
+ */
+ public MethodCallExpression newMethodCall(Expression target, String methodName, Expression[] arguments)
+ { if( target==null ||
+ methodName==null )
+ throw new NullPointerException();
+ MethodCallExpression methodCall;
+ if( methodName.equals("contains") ) //NOI18N
+ methodCall = new ContainsCallExpr( target, arguments );
+ else if( methodName.equals("endsWith") ) //NOI18N
+ methodCall = new EndsWithCallExpr( target, arguments );
+ else if( methodName.equals("isEmpty") ) //NOI18N
+ methodCall = new IsEmptyCallExpr( target );
+ else if( methodName.equals("startsWith") ) //NOI18N
+ methodCall = new StartsWithCallExpr( target, arguments );
+ else
+ throw new JDOQueryException( msg.msg("EXC_NonSupportedMethodCall", methodName) ); //NOI18N
+ return methodCall;
+ }
+
+ /**
+ * Returns an instance of <code>CastExpression</code>.
+ * This method throws <code>NullPointerException</code> if one of the arguments
+ * <code>clazz</code> or <code>expression</code>
+ * are <code>null</code>.
+ * @param clazz the Java class to cast the argument <code>expression</code> to
+ * @param expression the expression to cast
+ * @return the cast expression instance
+ * @exception NullPointerException if expression is null
+ */
+ public CastExpression newCast(Class clazz, Expression expression)
+ { if( clazz==null ||
+ expression==null )
+ throw new NullPointerException();
+ return new CastExpr( new TypeImpl(clazz), expression );
+ }
+
+ /**
+ * Returns an instance of <code>ConstantExpression</code>.
+ * This method handles <code>null</code> as a constant expression.
+ * @param value the object wrapped by the constant expression
+ * @return the constant expression instance
+ */
+ public ConstantExpression newConstant(Object value)
+ { return ConstantExpr.newConstant( value );
+ }
+
+ /**
+ * Returns an instance of <code>BooleanLiteralExpression</code>.
+ * @param b the value wrapped by the boolean expression
+ * @return the boolean expression instance
+ */
+ public ConstantExpression newConstant(boolean b)
+ { return new BooleanLiteralExpr( b );
+ }
+
+ /**
+ * Returns an instance of <code>ByteLiteralExpression</code>.
+ * @param b the value wrapped by the byte expression
+ * @return the byte expression instance
+ */
+ public ConstantExpression newConstant(byte b)
+ { return new ByteLiteralExpr( b );
+ }
+
+ /**
+ * Returns an instance of <code>CharLiteralExpression</code>.
+ * @param c the value wrapped by the char expression
+ * @return the char expression instance
+ */
+ public ConstantExpression newConstant(char c)
+ { return new CharLiteralExpr( c );
+ }
+
+ /**
+ * Returns an instance of <code>DoubleLiteralExpression</code>.
+ * @param d the value wrapped by the double expression
+ * @return the double expression instance
+ */
+ public ConstantExpression newConstant(double d)
+ { return new DoubleLiteralExpr( d );
+ }
+
+ /**
+ * Returns an instance of <code>FloatLiteralExpression</code>.
+ * @param f the value wrapped by the float expression
+ * @return the float expression instance
+ */
+ public ConstantExpression newConstant(float f)
+ { return new FloatLiteralExpr( f );
+ }
+
+ /**
+ * Returns an instance of <code>IntLiteralExpression</code>.
+ * @param i the value wrapped by the int expression
+ * @return the int expression instance
+ */
+ public ConstantExpression newConstant(int i)
+ { return new IntLiteralExpr( i );
+ }
+
+ /**
+ * Returns an instance of <code>LongLiteralExpression</code>.
+ * @param l the value wrapped by the long expression
+ * @return the long expression instance
+ */
+ public ConstantExpression newConstant(long l)
+ { return new LongLiteralExpr( l );
+ }
+
+ /**
+ * Returns an instance of <code>ShortLiteralExpression</code>.
+ * @param s the value wrapped by the short expression
+ * @return the short expression instance
+ */
+ public ConstantExpression newConstant(short s)
+ { return new ShortLiteralExpr( s );
+ }
+
+ /**
+ * Returns a complement expression for the argument
+ * <code>expr</code>.
+ * This method throws <code>NullPointerException</code> if the argument
+ * <code>expr</code> is <code>null</code>.
+ * @param expr the expression argument for the operation
+ * @return the complement expression instance
+ * @exception NullPointerException if expr is null
+ */
+ public ComplementExpression newComplement(Expression expr)
+ { if( expr==null )
+ throw new NullPointerException();
+ return new ComplementExpr( expr );
+ }
+
+ /**
+ * Returns a unary minus expression for the argument
+ * <code>expr</code>.
+ * This method throws <code>NullPointerException</code> if the argument
+ * <code>expr</code> is <code>null</code>.
+ * @param expr the expression argument for the operation
+ * @return the unary minus expression instance
+ * @exception NullPointerException if expr is null
+ */
+ public UnaryMinusExpression newMinus(Expression expr)
+ { if( expr==null )
+ throw new NullPointerException();
+ return new UnaryMinusExpr( expr );
+ }
+
+ /**
+ * Returns a not expression for the argument
+ * <code>expr</code>.
+ * This method throws <code>NullPointerException</code> if the argument
+ * <code>expr</code> is <code>null</code>.
+ * @param expr the expression argument for the operation
+ * @return the not expression instance
+ * @exception NullPointerException if expr is null
+ */
+ public NotExpression newNot(Expression expr)
+ { if( expr==null )
+ throw new NullPointerException();
+ return new NotExpr( expr );
+ }
+
+ /**
+ * Returns a plus expression for the argument
+ * <code>expr</code>.
+ * This method throws <code>NullPointerException</code> if the argument
+ * <code>expr</code> is <code>null</code>.
+ * @param expr the expression argument for the operation
+ * @return the plus expression instance
+ * @exception NullPointerException if expr is null
+ */
+ public UnaryPlusExpression newPlus(Expression expr)
+ { if( expr==null )
+ throw new NullPointerException();
+ return new UnaryPlusExpr( expr );
+ }
+
+ /**
+ * Returns an and expression for the arguments
+ * <code>left</code> and <code>right</code>.
+ * This method throws <code>NullPointerException</code> if one of the arguments
+ * <code>left</code> or <code>right</code> are <code>null</code>.
+ * @param left the left expression argument for the operation
+ * @param right the right expression argument for the operation
+ * @return the and expression instance
+ * @exception NullPointerException if left or right are null
+ */
+ public AndExpression newAnd(Expression left, Expression right)
+ { if( left==null ||
+ right==null )
+ throw new NullPointerException();
+ return new AndExpr( left, right );
+ }
+
+ /**
+ * Returns a conditional and expression for the arguments
+ * <code>left</code> and <code>right</code>.
+ * This method throws <code>NullPointerException</code> if one of the arguments
+ * <code>left</code> or <code>right</code> are <code>null</code>.
+ * @param left the left expression argument for the operation
+ * @param right the right expression argument for the operation
+ * @return the conditional and expression instance
+ * @exception NullPointerException if left or right are null
+ */
+ public ConditionalAndExpression newConditionalAnd(Expression left, Expression right)
+ { if( left==null ||
+ right==null )
+ throw new NullPointerException();
+ return new ConditionalAndExpr( left, right );
+ }
+
+ /**
+ * Returns a conditional or expression for the arguments
+ * <code>left</code> and <code>right</code>.
+ * This method throws <code>NullPointerException</code> if one of the arguments
+ * <code>left</code> or <code>right</code> are <code>null</code>.
+ * @param left the left expression argument for the operation
+ * @param right the right expression argument for the operation
+ * @return the conditional or expression instance
+ * @exception NullPointerException if left or right are null
+ */
+ public ConditionalOrExpression newConditionalOr(Expression left, Expression right)
+ { if( left==null ||
+ right==null )
+ throw new NullPointerException();
+ return new ConditionalOrExpr( left, right );
+ }
+
+ /**
+ * Returns a divide expression for the arguments
+ * <code>left</code> and <code>right</code>.
+ * This method throws <code>NullPointerException</code> if one of the arguments
+ * <code>left</code> or <code>right</code> are <code>null</code>.
+ * @param left the left expression argument for the operation
+ * @param right the right expression argument for the operation
+ * @return the divide expression instance
+ * @exception NullPointerException if left or right are null
+ */
+ public DivideExpression newDivide(Expression left, Expression right)
+ { if( left==null ||
+ right==null )
+ throw new NullPointerException();
+ return new DivideExpr( left, right );
+ }
+
+ /**
+ * Returns an equals expression for the arguments
+ * <code>left</code> and <code>right</code>.
+ * This method throws <code>NullPointerException</code> if one of the arguments
+ * <code>left</code> or <code>right</code> are <code>null</code>.
+ * @param left the left expression argument for the operation
+ * @param right the right expression argument for the operation
+ * @return the equals expression instance
+ * @exception NullPointerException if left or right are null
+ */
+ public EqualsExpression newEquals(Expression left, Expression right)
+ { if( left==null ||
+ right==null )
+ throw new NullPointerException();
+ return new EqualsExpr( left, right );
+ }
+
+ /**
+ * Returns a greater than expression for the arguments
+ * <code>left</code> and <code>right</code>.
+ * This method throws <code>NullPointerException</code> if one of the arguments
+ * <code>left</code> or <code>right</code> are <code>null</code>.
+ * @param left the left expression argument for the operation
+ * @param right the right expression argument for the operation
+ * @return the greater than expression instance
+ * @exception NullPointerException if left or right are null
+ */
+ public GreaterThanExpression newGreaterThan(Expression left, Expression right)
+ { if( left==null ||
+ right==null )
+ throw new NullPointerException();
+ return new GreaterThanExpr( left, right );
+ }
+
+ /**
+ * Returns a greater than equals expression for the arguments
+ * <code>left</code> and <code>right</code>.
+ * This method throws <code>NullPointerException</code> if one of the arguments
+ * <code>left</code> or <code>right</code> are <code>null</code>.
+ * @param left the left expression argument for the operation
+ * @param right the right expression argument for the operation
+ * @return the greater than equals expression instance
+ * @exception NullPointerException if left or right are null
+ */
+ public GreaterThanEqualsExpression newGreaterThanEquals(Expression left, Expression right)
+ { if( left==null ||
+ right==null )
+ throw new NullPointerException();
+ return new GreaterThanEqualsExpr( left, right );
+ }
+
+ /**
+ * Returns a less than expression for the arguments
+ * <code>left</code> and <code>right</code>.
+ * This method throws <code>NullPointerException</code> if one of the arguments
+ * <code>left</code> or <code>right</code> are <code>null</code>.
+ * @param left the left expression argument for the operation
+ * @param right the right expression argument for the operation
+ * @return the less than expression instance
+ * @exception NullPointerException if left or right are null
+ */
+ public LessThanExpression newLessThan(Expression left, Expression right)
+ { if( left==null ||
+ right==null )
+ throw new NullPointerException();
+ return new LessThanExpr( left, right );
+ }
+
+ /**
+ * Returns a less than equals expression for the arguments
+ * <code>left</code> and <code>right</code>.
+ * This method throws <code>NullPointerException</code> if one of the arguments
+ * <code>left</code> or <code>right</code> are <code>null</code>.
+ * @param left the left expression argument for the operation
+ * @param right the right expression argument for the operation
+ * @return the less than equals expression instance
+ * @exception NullPointerException if left or right are null
+ */
+ public LessThanEqualsExpression newLessThanEquals(Expression left, Expression right)
+ { if( left==null ||
+ right==null )
+ throw new NullPointerException();
+ return new LessThanEqualsExpr( left, right );
+ }
+
+ /**
+ * Returns a minus expression for the arguments
+ * <code>left</code> and <code>right</code>.
+ * This method throws <code>NullPointerException</code> if one of the arguments
+ * <code>left</code> or <code>right</code> are <code>null</code>.
+ * @param left the left expression argument for the operation
+ * @param right the right expression argument for the operation
+ * @return the minus expression instance
+ * @exception NullPointerException if left or right are null
+ */
+ public MinusExpression newMinus(Expression left, Expression right)
+ { if( left==null ||
+ right==null )
+ throw new NullPointerException();
+ return new MinusExpr( left, right );
+ }
+
+ /**
+ * Returns a not equals expression for the arguments
+ * <code>left</code> and <code>right</code>.
+ * This method throws <code>NullPointerException</code> if one of the arguments
+ * <code>left</code> or <code>right</code> are <code>null</code>.
+ * @param left the left expression argument for the operation
+ * @param right the right expression argument for the operation
+ * @return the not equals expression instance
+ * @exception NullPointerException if left or right are null
+ */
+ public NotEqualsExpression newNotEquals(Expression left, Expression right)
+ { if( left==null ||
+ right==null )
+ throw new NullPointerException();
+ return new NotEqualsExpr( left, right );
+ }
+
+ /**
+ * Returns a plus expression for the arguments
+ * <code>left</code> and <code>right</code>.
+ * This method throws <code>NullPointerException</code> if one of the arguments
+ * <code>left</code> or <code>right</code> are <code>null</code>.
+ * @param left the left expression argument for the operation
+ * @param right the right expression argument for the operation
+ * @return the plus expression instance
+ * @exception NullPointerException if left or right are null
+ */
+ public PlusExpression newPlus(Expression left, Expression right)
+ { if( left==null ||
+ right==null )
+ throw new NullPointerException();
+ return new PlusExpr( left, right );
+ }
+
+ /**
+ * Returns an or expression for the arguments
+ * <code>left</code> and <code>right</code>.
+ * This method throws <code>NullPointerException</code> if one of the arguments
+ * <code>left</code> or <code>right</code> are <code>null</code>.
+ * @param left the left expression argument for the operation
+ * @param right the right expression argument for the operation
+ * @return the or expression instance
+ * @exception NullPointerException if left or right are null
+ */
+ public OrExpression newOr(Expression left, Expression right)
+ { if( left==null ||
+ right==null )
+ throw new NullPointerException();
+ return new OrExpr( left, right );
+ }
+
+ /**
+ * Returns a times expression for the arguments
+ * <code>left</code> and <code>right</code>.
+ * This method throws <code>NullPointerException</code> if one of the arguments
+ * <code>left</code> or <code>right</code> are <code>null</code>.
+ * @param left the left expression argument for the operation
+ * @param right the right expression argument for the operation
+ * @return the times expression instance
+ * @exception NullPointerException if left or right are null
+ */
+ public TimesExpression newTimes(Expression left, Expression right)
+ { if( left==null ||
+ right==null )
+ throw new NullPointerException();
+ return new TimesExpr( left, right );
+ }
+
+ /**
+ * Returns the children of this node.
+ * This method ensures that the children array corresponds with
+ * the children nodes of the underlying ANTLR tree structure.
+ * @return the children
+ * @exception JDOQueryException if the candidate class is not set
+ */
+ public Node[] getChildren()
+ { initANTLRAST();
+ return super.getChildren();
+ }
+
+ /**
+ * Delegates to the argument <code>visitor</code>.
+ * @param visitor the node visitor
+ */
+ public void arrive(NodeVisitor visitor)
+ { visitor.arrive( this );
+ }
+
+ /**
+ * Delegates to the argument <code>visitor</code>.
+ * @param visitor the node visitor
+ * @param results the result array
+ * @return the object returned by the visitor instance
+ */
+ public Object leave(NodeVisitor visitor, Object[] results)
+ { return visitor.leave( this, results );
+ }
+
+ /**
+ * Delegates to the argument <code>visitor</code>.
+ * @param visitor the node visitor
+ * @param resultOfPreviousChild the result computed by leaving the
+ * previous child node.
+ * @param indexOfNextChild the index of the next child node
+ * @return the boolean value returned by the visitor instance
+ */
+ public boolean walkNextChild(NodeVisitor visitor, Object resultOfPreviousChild, int indexOfNextChild)
+ { return visitor.walkNextChild( this, resultOfPreviousChild, indexOfNextChild );
+ }
+
+ /**
+ * Ensures that this node has a corresponding ANTLR tree structure.
+ * @exception JDOQueryException if the candidate class is not set
+ */
+ public void initANTLRAST()
+ { if( getFirstChild()==null )
+ { if( this.candidateClass==null )
+ throw new JDOQueryException( msg.msg("EXC_MissingCandidateClass") ); //NOI18N
+
+ setFirstChild( (AST) this.candidateClass );
+ AST current = (AST) candidateClass;
+ for( Iterator i=this.parameterList.iterator(); i.hasNext(); )
+ { current.setNextSibling( (AST) i.next() );
+ current = current.getNextSibling();
+ }
+ for( Iterator i=this.variableMap.values().iterator(); i.hasNext(); )
+ { current.setNextSibling( (AST) i.next() );
+ current = current.getNextSibling();
+ }
+ for( Iterator i=this.orderings.iterator(); i.hasNext(); )
+ { current.setNextSibling( (AST) i.next() );
+ current = current.getNextSibling();
+ }
+ current.setNextSibling( (AST) this.filter );
+ }
+ }
+
+ /**
+ * Nullifies the declared fields in this node as well as the underlying
+ * ANTLR tree structure.
+ */
+ private void reset()
+ { this.candidateClass = null;
+ this.parameterMap.clear();
+ this.parameterList.clear();
+ this.variableMap.clear();
+ this.orderings.clear();
+ this.filter = null;
+ this.children = null;
+
+ this.parent = null;
+ setFirstChild( null );
+ setChildren( null );
+ }
+
+ private void init()
+ { this.candidateClass = null;
+ this.parameterMap = new HashMap();
+ this.parameterList = new LinkedList();
+ this.variableMap = new HashMap();
+ this.orderings = new LinkedList();
+ this.filter = null;
+ }
+
+ static Class toWrapperClass(Class clazz)
+ { if( clazz==boolean.class )
+ clazz = Boolean.class;
+ if( clazz==byte.class )
+ clazz = Byte.class;
+ if( clazz==char.class )
+ clazz = Character.class;
+ if( clazz==double.class )
+ clazz = Double.class;
+ if( clazz==float.class )
+ clazz = Float.class;
+ if( clazz==int.class )
+ clazz = Integer.class;
+ if( clazz==long.class )
+ clazz = Long.class;
+ if( clazz==short.class )
+ clazz = Short.class;
+ return clazz;
+ }
+
+ static class JavaKeyWords
+ { Collection javaKeyWords = new HashSet();
+ JavaKeyWords()
+ { javaKeyWords.add( "abstract" ); //NOI18N
+ javaKeyWords.add( "boolean" ); //NOI18N
+ javaKeyWords.add( "break" ); //NOI18N
+ javaKeyWords.add( "byte" ); //NOI18N
+ javaKeyWords.add( "case" ); //NOI18N
+ javaKeyWords.add( "catch" ); //NOI18N
+ javaKeyWords.add( "char" ); //NOI18N
+ javaKeyWords.add( "class" ); //NOI18N
+ javaKeyWords.add( "const" ); //NOI18N
+ javaKeyWords.add( "continue" ); //NOI18N
+ javaKeyWords.add( "default" ); //NOI18N
+ javaKeyWords.add( "do" ); //NOI18N
+ javaKeyWords.add( "double" ); //NOI18N
+ javaKeyWords.add( "else" ); //NOI18N
+ javaKeyWords.add( "extends" ); //NOI18N
+ javaKeyWords.add( "final" ); //NOI18N
+ javaKeyWords.add( "finally" ); //NOI18N
+ javaKeyWords.add( "float" ); //NOI18N
+ javaKeyWords.add( "for" ); //NOI18N
+ javaKeyWords.add( "goto" ); //NOI18N
+ javaKeyWords.add( "if" ); //NOI18N
+ javaKeyWords.add( "implements" ); //NOI18N
+ javaKeyWords.add( "import" ); //NOI18N
+ javaKeyWords.add( "instanceof" ); //NOI18N
+ javaKeyWords.add( "int" ); //NOI18N
+ javaKeyWords.add( "interface" ); //NOI18N
+ javaKeyWords.add( "long" ); //NOI18N
+ javaKeyWords.add( "native" ); //NOI18N
+ javaKeyWords.add( "new" ); //NOI18N
+ javaKeyWords.add( "package" ); //NOI18N
+ javaKeyWords.add( "private" ); //NOI18N
+ javaKeyWords.add( "protected" ); //NOI18N
+ javaKeyWords.add( "public" ); //NOI18N
+ javaKeyWords.add( "return" ); //NOI18N
+ javaKeyWords.add( "short" ); //NOI18N
+ javaKeyWords.add( "static" ); //NOI18N
+ javaKeyWords.add( "strictfp" ); //NOI18N
+ javaKeyWords.add( "super" ); //NOI18N
+ javaKeyWords.add( "switch" ); //NOI18N
+ javaKeyWords.add( "synchronized" ); //NOI18N
+ javaKeyWords.add( "this" ); //NOI18N
+ javaKeyWords.add( "throw" ); //NOI18N
+ javaKeyWords.add( "throws" ); //NOI18N
+ javaKeyWords.add( "transient" ); //NOI18N
+ javaKeyWords.add( "try" ); //NOI18N
+ javaKeyWords.add( "void" ); //NOI18N
+ javaKeyWords.add( "volatile" ); //NOI18N
+ javaKeyWords.add( "while" ); //NOI18N
+ }
+ /**
+ * Checks if the argument <code>identifier</code> equals a Java key word.
+ * @param identifier the identifier to check
+ * @return <code>true</code>, if <code>identifier</code> is a Java key word,
+ * else <code>false</code>
+ */
+ private boolean isJavaKeyWord(String identifier)
+ { return javaKeyWords.contains(identifier);
+ }
+ }
+
+ // Serialization support
+
+ /**
+ * Returns the candidate class name calculated during serialization of
+ * this query tree instance.
+ * @return serialized candidate class name
+ */
+ public String getSerializedCandidateClassName()
+ {
+ return serializedCandidateClassName;
+ }
+
+ /** Deserialization support. */
+ private void writeObject(java.io.ObjectOutputStream out)
+ throws java.io.IOException
+ {
+ if ((candidateClass != null) && (getCandidateClass() != null))
+ this.serializedCandidateClassName = getCandidateClass().getName();
+ out.defaultWriteObject();
+ }
+}
+
Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/jdoql/tree/TypeImpl.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/jdoql/tree/TypeImpl.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/jdoql/tree/TypeImpl.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/jdoql/tree/TypeImpl.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,93 @@
+/*
+ * 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.impl.jdoql.tree;
+
+import org.apache.jdo.impl.jdoql.jdoqlc.JDOQLTokenTypes;
+import org.apache.jdo.jdoql.tree.NodeVisitor;
+import org.apache.jdo.jdoql.tree.Type;
+
+
+/**
+ * This node represents a type instance. A type instance wraps a
+ * <code>java.lang.Class</code> instance which has been supplied by
+ * the application. The following nodes have type instances as children:
+ * <LI><code>CandidateClass</code>
+ * <LI><code>CastExpr</code>
+ * <LI><code>Decl</code>
+ * <LI><code>StaticFieldAccessExpr</code>
+ * The result type of a type instance is the wrapped <code>java.lang.Class</code>
+ * instance. Type instances are not visible in query tree factory methods and
+ * expression factory methods. They are internally created by in implementation
+ * and are walked by a node visitor.
+ *
+ * @author Michael Watzek
+ */
+public final class TypeImpl extends NodeImpl implements Type
+{
+ /**
+ * The noarg constructor is needed for ANTLR support and deserialization.
+ * The caller must make sure to set the ANTLR tree structure himself
+ * or, call <code>setChildren</code> optionally.
+ */
+ public TypeImpl()
+ {}
+
+ /**
+ * The noarg constructor is needed for ANTLR support.
+ * The caller must make sure to set the ANTLR tree structure himself
+ * or, call <code>setChildren</code> optionally.
+ */
+ public TypeImpl(antlr.Token token)
+ { initialize( token );
+ }
+
+ /**
+ * This constructor is called by the query tree instance.
+ * It delegates to the super class constructor.
+ * @param clazz the Java class which is wrapped by this instance
+ */
+ TypeImpl(Class clazz)
+ { super( JDOQLTokenTypes.TYPE, clazz.getName(), clazz );
+ }
+
+ /**
+ * Returns the string representation of the Java class,
+ * which is wrapped by this instance.
+ * @return the Java type name
+ */
+ public String getTypeName()
+ { return getJavaClass().getName();
+ }
+
+ /**
+ * Delegates to the argument <code>visitor</code>.
+ * @param visitor the node visitor
+ */
+ public void arrive(NodeVisitor visitor)
+ { visitor.arrive( this );
+ }
+
+ /**
+ * Delegates to the argument <code>visitor</code>.
+ * @param visitor the node visitor
+ * @param results the result array
+ * @return the object returned by the visitor instance
+ */
+ public Object leave(NodeVisitor visitor, Object[] results)
+ { return visitor.leave( this, results );
+ }
+}
Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/jdoql/tree/UnaryExpr.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/jdoql/tree/UnaryExpr.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/jdoql/tree/UnaryExpr.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/jdoql/tree/UnaryExpr.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,64 @@
+/*
+ * 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.impl.jdoql.tree;
+
+import org.apache.jdo.jdoql.tree.Expression;
+import org.apache.jdo.jdoql.tree.Node;
+import org.apache.jdo.jdoql.tree.UnaryExpression;
+
+/**
+ * This node represents a unary operator. All unary operators have exactly
+ * one children. Examples of binary operators
+ * are <code>ComplementExpression</code> and <code>NotExpression</code>.
+ *
+ * @author Michael Watzek
+ */
+public abstract class UnaryExpr extends Expr implements UnaryExpression
+{
+ /**
+ * The noarg constructor is needed for ANTLR support and deserialization.
+ * The caller must make sure to set the ANTLR tree structure himself
+ * or, call <code>setChildren</code> optionally.
+ */
+ public UnaryExpr()
+ {}
+
+ /**
+ * This constructor is called by specialized nodes.
+ * It calls <code>setChildren</code> in order to initialize the node's
+ * child <code>expr</code>.
+ * @param tokenType the token tpye
+ * @param tokenName the name of this node
+ * @param expr the first child
+ */
+ UnaryExpr(int tokenType, String tokenName, Expression expr)
+ { super( tokenType, tokenName, expr.getJavaClass() );
+ setChildren( new Node[] {expr} );
+ }
+
+ /**
+ * Returns the node's expression.
+ * @return the node's expression
+ */
+ public Expression getExpression()
+ { ASTToChildren();
+ if( this.children==null ||
+ this.children.length<1 )
+ return null;
+ return (Expression) this.children[0];
+ }
+}
Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/jdoql/tree/UnaryMinusExpr.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/jdoql/tree/UnaryMinusExpr.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/jdoql/tree/UnaryMinusExpr.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/jdoql/tree/UnaryMinusExpr.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,77 @@
+/*
+ * 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.impl.jdoql.tree;
+
+import org.apache.jdo.impl.jdoql.jdoqlc.JDOQLTokenTypes;
+import org.apache.jdo.jdoql.tree.Expression;
+import org.apache.jdo.jdoql.tree.NodeVisitor;
+import org.apache.jdo.jdoql.tree.UnaryMinusExpression;
+
+
+/**
+ * This node represents a unary minus operator.
+ * The string representation of this operator is <code>-</code>.
+ *
+ * @author Michael Watzek
+ */
+public final class UnaryMinusExpr
+ extends UnaryExpr implements UnaryMinusExpression
+{
+ /**
+ * The noarg constructor is needed for ANTLR support and deserialization.
+ * The caller must make sure to set the ANTLR tree structure himself
+ * or, call <code>setChildren</code> optionally.
+ */
+ public UnaryMinusExpr()
+ {}
+
+ /**
+ * The noarg constructor is needed for ANTLR support.
+ * The caller must make sure to set the ANTLR tree structure himself
+ * or, call <code>setChildren</code> optionally.
+ */
+ public UnaryMinusExpr(antlr.Token token)
+ { initialize( token );
+ }
+
+ /**
+ * This constructor is called by the query tree instance.
+ * It delegates to the super class constructor.
+ * @param expr the expression to compute the complement for
+ */
+ UnaryMinusExpr(Expression expr)
+ { super( JDOQLTokenTypes.UNARY_MINUS, "UnaryMinus", expr ); //NOI18N
+ }
+
+ /**
+ * Delegates to the argument <code>visitor</code>.
+ * @param visitor the node visitor
+ */
+ public void arrive(NodeVisitor visitor)
+ { visitor.arrive( this );
+ }
+
+ /**
+ * Delegates to the argument <code>visitor</code>.
+ * @param visitor the node visitor
+ * @param results the result array
+ * @return the object returned by the visitor instance
+ */
+ public Object leave(NodeVisitor visitor, Object[] results)
+ { return visitor.leave( this, results );
+ }
+}
Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/jdoql/tree/UnaryPlusExpr.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/jdoql/tree/UnaryPlusExpr.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/jdoql/tree/UnaryPlusExpr.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/jdoql/tree/UnaryPlusExpr.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,76 @@
+/*
+ * 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.impl.jdoql.tree;
+
+import org.apache.jdo.impl.jdoql.jdoqlc.JDOQLTokenTypes;
+import org.apache.jdo.jdoql.tree.Expression;
+import org.apache.jdo.jdoql.tree.NodeVisitor;
+import org.apache.jdo.jdoql.tree.UnaryPlusExpression;
+
+
+/**
+ * This node represents a unary plus operator.
+ * The string representation of this operator is <code>+</code>.
+ *
+ * @author Michael Watzek
+ */
+public final class UnaryPlusExpr extends UnaryExpr implements UnaryPlusExpression
+{
+ /**
+ * The noarg constructor is needed for ANTLR support and deserialization.
+ * The caller must make sure to set the ANTLR tree structure himself
+ * or, call <code>setChildren</code> optionally.
+ */
+ public UnaryPlusExpr()
+ {}
+
+ /**
+ * The noarg constructor is needed for ANTLR support.
+ * The caller must make sure to set the ANTLR tree structure himself
+ * or, call <code>setChildren</code> optionally.
+ */
+ public UnaryPlusExpr(antlr.Token token)
+ { initialize( token );
+ }
+
+ /**
+ * This constructor is called by the query tree instance.
+ * It delegates to the super class constructor.
+ * @param expr the expression to compute the complement for
+ */
+ UnaryPlusExpr(Expression expr)
+ { super( JDOQLTokenTypes.UNARY_PLUS, "UnaryPlus", expr ); //NOI18N
+ }
+
+ /**
+ * Delegates to the argument <code>visitor</code>.
+ * @param visitor the node visitor
+ */
+ public void arrive(NodeVisitor visitor)
+ { visitor.arrive( this );
+ }
+
+ /**
+ * Delegates to the argument <code>visitor</code>.
+ * @param visitor the node visitor
+ * @param results the result array
+ * @return the object returned by the visitor instance
+ */
+ public Object leave(NodeVisitor visitor, Object[] results)
+ { return visitor.leave( this, results );
+ }
+}
Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/jdoql/tree/VariableAccessExpr.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/jdoql/tree/VariableAccessExpr.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/jdoql/tree/VariableAccessExpr.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/jdoql/tree/VariableAccessExpr.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,81 @@
+/*
+ * 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.impl.jdoql.tree;
+
+import org.apache.jdo.impl.jdoql.jdoqlc.JDOQLTokenTypes;
+import org.apache.jdo.jdoql.tree.Declaration;
+import org.apache.jdo.jdoql.tree.Expression;
+import org.apache.jdo.jdoql.tree.NodeVisitor;
+import org.apache.jdo.jdoql.tree.VariableAccessExpression;
+
+
+/**
+ * This node represents a variable access expression.
+ * It does not have any children.
+ *
+ * @author Michael Watzek
+ */
+public final class VariableAccessExpr
+ extends IdentifierExpr implements VariableAccessExpression
+{
+ /**
+ * The noarg constructor is needed for ANTLR support and deserialization.
+ * The caller must make sure to set the ANTLR tree structure himself
+ * or, call <code>setChildren</code> optionally.
+ */
+ public VariableAccessExpr()
+ {}
+
+ /**
+ * The noarg constructor is needed for ANTLR support.
+ * The caller must make sure to set the ANTLR tree structure himself
+ * or, call <code>setChildren</code> optionally.
+ */
+ public VariableAccessExpr(antlr.Token token)
+ { initialize( token );
+ }
+
+ /**
+ * This constructor is called by the query tree instance.
+ * It delegates to the super class constructor.
+ * @param clazz the Java type of this identifier
+ * @param name the name of this identifier
+ */
+ VariableAccessExpr(Class clazz, String name)
+ { super( JDOQLTokenTypes.VARIABLE_ACCESS, name,
+ Tree.toWrapperClass(clazz) );
+ }
+
+ /**
+ * Delegates to the argument <code>visitor</code>.
+ * @param visitor the node visitor
+ */
+ public void arrive(NodeVisitor visitor)
+ { visitor.arrive( this );
+ }
+
+ /**
+ * Delegates to the argument <code>visitor</code>.
+ * @param visitor the node visitor
+ * @param results the result array
+ * @return the object returned by the visitor instance
+ */
+ public Object leave(NodeVisitor visitor, Object[] results)
+ { return visitor.leave( this, results );
+ }
+}
+
Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/jdoql/tree/VariableDecl.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/jdoql/tree/VariableDecl.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/jdoql/tree/VariableDecl.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/jdoql/tree/VariableDecl.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,77 @@
+/*
+ * 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.impl.jdoql.tree;
+
+import org.apache.jdo.impl.jdoql.jdoqlc.JDOQLTokenTypes;
+import org.apache.jdo.jdoql.tree.NodeVisitor;
+import org.apache.jdo.jdoql.tree.Type;
+import org.apache.jdo.jdoql.tree.VariableDeclaration;
+
+
+/**
+ * This node represents a variable declaration.
+ * It does not have any children.
+ *
+ * @author Michael Watzek
+ */
+public final class VariableDecl extends Decl implements VariableDeclaration
+{
+ /**
+ * The noarg constructor is needed for ANTLR support and deserialization.
+ * The caller must make sure to set the ANTLR tree structure himself
+ * or, call <code>setChildren</code> optionally.
+ */
+ public VariableDecl()
+ {}
+
+ /**
+ * The noarg constructor is needed for ANTLR support.
+ * The caller must make sure to set the ANTLR tree structure himself
+ * or, call <code>setChildren</code> optionally.
+ */
+ public VariableDecl(antlr.Token token)
+ { initialize( token );
+ }
+
+ /**
+ * This constructor delegates to the super class constructor.
+ * @param type the type instance wrapping the Java class
+ * @param name the name of the variable
+ */
+ VariableDecl(Type type, String name)
+ { super( JDOQLTokenTypes.VARIABLE_DECL, "VariableDeclaration",
+ type, name ); //NOI18N
+ }
+
+ /**
+ * Delegates to the argument <code>visitor</code>.
+ * @param visitor the node visitor
+ */
+ public void arrive(NodeVisitor visitor)
+ { visitor.arrive( this );
+ }
+
+ /**
+ * Delegates to the argument <code>visitor</code>.
+ * @param visitor the node visitor
+ * @param results the result array
+ * @return the object returned by the visitor instance
+ */
+ public Object leave(NodeVisitor visitor, Object[] results)
+ { return visitor.leave( this, results );
+ }
+}
Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/model/java/AbstractJavaField.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/model/java/AbstractJavaField.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/model/java/AbstractJavaField.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/model/java/AbstractJavaField.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,154 @@
+/*
+ * 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.impl.model.java;
+
+import org.apache.jdo.model.java.JavaField;
+import org.apache.jdo.model.java.JavaType;
+import org.apache.jdo.model.jdo.JDOField;
+
+
+/**
+ * Abstract super class for JavaField implementations.
+ * It provides getters for the name and declaringClass properties which are
+ * initialized in the constructor. The implementation of method getJDOField
+ * always returns <code>null</code>.
+ * <p>
+ * A non-abstract subclass must implement methods
+ * {@link #getModifiers()} and {@link #getType()}. Note, this
+ * implementation of method {@link #getJDOField()} always returns
+ * <code>null</code>, so a subclass may want to override this method.
+ *
+ * @author Michael Bouschen
+ * @since JDO 1.0.1
+ */
+abstract public class AbstractJavaField
+ implements JavaField
+{
+ /** The Field name. */
+ private String name;
+
+ /** The declaring class. */
+ private JavaType declaringClass;
+
+ /**
+ * Constructor setting the name and declaringClass property.
+ * @param name field name
+ * @param declaringClass the JavaType of the class or interface that
+ * declares this JavaField.
+ */
+ public AbstractJavaField(String name, JavaType declaringClass)
+ {
+ this.name = name;
+ this.declaringClass = declaringClass;
+ }
+
+ /**
+ * Returns the name of the field.
+ * @return field name
+ */
+ public String getName()
+ {
+ return name;
+ }
+
+ /**
+ * Returns the Java language modifiers for the field represented by
+ * this JavaField, as an integer. The java.lang.reflect.Modifier class
+ * should be used to decode the modifiers.
+ * @return the Java language modifiers for this JavaField
+ * @see java.lang.reflect.Modifier
+ */
+ abstract public int getModifiers();
+
+ /**
+ * Returns the JavaType representation of the field type.
+ * @return field type
+ */
+ abstract public JavaType getType();
+
+ /**
+ * Returns the JavaType instance representing the class or interface
+ * that declares the field represented by this JavaField instance.
+ * @return the JavaType instance of the declaring class.
+ */
+ public JavaType getDeclaringClass()
+ {
+ return declaringClass;
+ }
+
+ /**
+ * Returns the corresponding JDOField instance, if the JDOModel
+ * provides any JDO metadata for the field represented by this
+ * JavaField. If there is no corresponding JDOField representation, the
+ * method returns <code>null</code>.
+ * <p>
+ * This implementation always returns <code>null</code>.
+ * @return the corresponding JDOField instance (if available);
+ * <code>null</code> otherwise.
+ */
+ public JDOField getJDOField()
+ {
+ return null;
+ }
+
+ // ===== Methods not defined in JavaField =====
+
+ /**
+ * Indicates whether some other object is "equal to" this one.
+ * @param obj the reference object with which to compare.
+ * <p>
+ * This implementation matches the declaring class and the name of the
+ * specified object to the declaring class and the name of this
+ * JavaField.
+ * @return <code>true</code> if this object is the same as the obj
+ * argument; <code>false</code> otherwise.
+ */
+ public boolean equals(Object obj)
+ {
+ // return true if obj is this
+ if (obj == this) return true;
+ // return false if obj does not have the correct type
+ if ((obj == null) || !(obj instanceof JavaField)) return false;
+
+ JavaField other = (JavaField)obj;
+ // compare declaringClass and field names
+ return (getDeclaringClass() == other.getDeclaringClass())
+ && (getName().equals(other.getName()));
+ }
+
+ /**
+ * Returns a hash code value for the object.
+ * <p>
+ * This is computed as the exclusive-or of the hashcodes for the
+ * underlying field's declaring class name and its name.
+ * @return a hash code value for this object.
+ */
+ public int hashCode()
+ {
+ return getDeclaringClass().getName().hashCode() ^ getName().hashCode();
+ }
+
+ /**
+ * Returns a string representation of the object.
+ * @return a string representation of the object.
+ */
+ public String toString()
+ {
+ return getDeclaringClass().getName() + "." + getName();
+ }
+}
+
Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/model/java/AbstractJavaModel.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/model/java/AbstractJavaModel.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/model/java/AbstractJavaModel.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/model/java/AbstractJavaModel.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,175 @@
+/*
+ * 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.impl.model.java;
+
+import java.util.Map;
+import java.util.Set;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.io.InputStream;
+
+import org.apache.jdo.model.ModelException;
+import org.apache.jdo.model.java.JavaModel;
+import org.apache.jdo.model.java.JavaType;
+import org.apache.jdo.model.jdo.JDOModel;
+
+
+/**
+ * Abstract super class for JavaModel implementations.
+ * It implements the jdoModel property and the parent/child relationship
+ * between javaModels. It also provides a map of types managed by this
+ * JavaModel (see {@link #types}). The AbstractJavaModel constructor
+ * automatically adds all the predefined types to this map.
+ * <p>
+ * A non-abstract subclass must implement methods
+ * {@link #getJavaType(String name)} and
+ * {@link #getInputStreamForResource(String resourceName)}.
+ *
+ * @author Michael Bouschen
+ * @since JDO 1.0.1
+ */
+abstract public class AbstractJavaModel
+ implements JavaModel
+{
+ /** Map of known JavaTypes. Key is the type name as a string. */
+ protected Map types;
+
+ /** The parent JavaModel. */
+ protected JavaModel parent;
+
+ /** The child JavaModels. */
+ protected Set children = new HashSet();
+
+ /** The corresponding JDOModel instance. */
+ protected JDOModel jdoModel;
+
+ /**
+ * Constructor. It adds all predefined types to the cache of types
+ * known by this model instance.
+ * @see PredefinedType
+ */
+ protected AbstractJavaModel()
+ {
+ types = new HashMap(PredefinedType.getPredefinedTypes());
+ }
+
+ /**
+ * The method returns the JavaType instance for the specified type
+ * name. A type name is unique within one JavaModel instance. The
+ * method returns <code>null</code> if this model instance does not
+ * know a type with the specified name.
+ * @return a JavaType instance for the specified name or
+ * <code>null</code> if not present in this model instance.
+ */
+ abstract public JavaType getJavaType(String name);
+
+ /**
+ * The method returns the JavaType instance for the type name of the
+ * specified class object. This is a convenience method for
+ * <code>getJavaType(clazz.getName())</code>. The major difference
+ * between this method and getJavaType taking a type name is that this
+ * method is supposed to return a non-<code>null<code> value. The
+ * specified class object describes an existing type.
+ * @param clazz the Class instance representing the type
+ * @return a JavaType instance for the name of the specified class
+ * object.
+ */
+ public JavaType getJavaType(Class clazz)
+ {
+ return (clazz == null) ? null : getJavaType(clazz.getName());
+ }
+
+ /**
+ * Finds a resource with a given name. A resource is some data that can
+ * be accessed by class code in a way that is independent of the
+ * location of the code. The name of a resource is a "/"-separated path
+ * name that identifies the resource. The method method opens the
+ * resource for reading and returns an InputStream. It returns
+ * <code>null</code> if no resource with this name is found or if the
+ * caller doesn't have adequate privileges to get the resource.
+ * @param resourceName the resource name
+ * @return an input stream for reading the resource, or <code>null</code>
+ * if the resource could not be found or if the caller doesn't have
+ * adequate privileges to get the resource.
+ */
+ abstract public InputStream getInputStreamForResource(String resourceName);
+
+ /**
+ * Returns the parent JavaModel instance of this JavaModel.
+ * @return the parent JavaModel
+ */
+ public JavaModel getParent()
+ {
+ return parent;
+ }
+
+ /**
+ * Set the parent JavaModel for this JavaModel. The method
+ * automatically adds this JavaModel to the collection of children
+ * of the specified parent JavaModel.
+ * @param parent the parent JavaModel
+ * @exception ModelException if impossible
+ */
+ public void setParent(JavaModel parent)
+ throws ModelException
+ {
+ if (this.parent == parent) {
+ // no changes => return;
+ return;
+ }
+ if (this.parent != null) {
+ // remove this from the collection of children of the old parent
+ ((AbstractJavaModel)this.parent).children.remove(this);
+ // add this to the collection of children of the new parent
+ ((AbstractJavaModel)parent).children.add(this);
+ }
+ this.parent = parent;
+ }
+
+ /**
+ * Returns a collection of child JavaModel instances in the form
+ * of an array. All instances from the returned array have this
+ * JavaModel instance as parent.
+ * @return the child JavaModel instances
+ */
+ public JavaModel[] getChildren()
+ {
+ return (JavaModel[])children.toArray(new JavaModel[children.size()]);
+ }
+
+ /**
+ * Returns the corresponding JDOModel instance.
+ * @return the corresponding JDOModel.
+ */
+ public JDOModel getJDOModel()
+ {
+ return jdoModel;
+ }
+
+ /**
+ * Sets the corresponding JDOModel instance.
+ * @param jdoModel the JDOModel instance
+ * @exception ModelException if impossible
+ */
+ public void setJDOModel(JDOModel jdoModel)
+ throws ModelException
+ {
+ this.jdoModel = jdoModel;
+ }
+
+}
+
Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/model/java/AbstractJavaModelFactory.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/model/java/AbstractJavaModelFactory.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/model/java/AbstractJavaModelFactory.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/model/java/AbstractJavaModelFactory.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,161 @@
+/*
+ * 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.impl.model.java;
+
+import java.util.Map;
+import java.util.HashMap;
+
+import org.apache.jdo.impl.model.jdo.JDOModelFactoryImplDynamic;
+import org.apache.jdo.model.ModelException;
+import org.apache.jdo.model.ModelFatalException;
+import org.apache.jdo.model.java.JavaModel;
+import org.apache.jdo.model.java.JavaModelFactory;
+import org.apache.jdo.model.java.JavaType;
+import org.apache.jdo.model.jdo.JDOModel;
+import org.apache.jdo.model.jdo.JDOModelFactory;
+import org.apache.jdo.util.I18NHelper;
+
+/**
+ * Abstract super class for JavaModelFactory implementations. It provides a
+ * JavaModel cache and implements the JavaModel lookup method
+ * {@link #getJavaModel(Object key)}. Any JavaModel instance returned by
+ * this method is automatically connected to its corresponding JDOModel
+ * instance.
+ * <p>
+ * A non-abstract subclass must implement method
+ * {@link #createJavaModel(Object key)}. The lookup method calls this
+ * method if it cannot find a JavaModel instance in the cache. The method
+ * should also check whether the specified key is of an appropriate type
+ * for the JavaModelFactory implementation. A subclass should check whether
+ * it can implement method {@link #getJavaType(Object typeDesc)}. The
+ * implementation in AbstractJavaModelFactory always throws a
+ * ModelFatalException.
+ *
+ * @author Michael Bouschen
+ * @since JDO 1.0.1
+ */
+abstract public class AbstractJavaModelFactory
+ implements JavaModelFactory
+{
+ /**
+ * Map of JavaModel instances, key is implementation specific.
+ * @see #getJavaModel(Object key)
+ */
+ private Map modelCache = new HashMap();
+
+ /** I18N support */
+ private static I18NHelper msg =
+ I18NHelper.getInstance(AbstractJavaModelFactory.class);
+
+ /**
+ * Creates a new empty JavaModel instance. A factory implementation may
+ * use the specified key when caching the new JavaModel instance.
+ * <p>
+ * Each JavaModelFactory imposes its own restrictions for the keys to
+ * cache JavaModel instances. Some implementation will allow only keys
+ * of a certain type. Some implementations will prohibit
+ * <code>null</code> keys. Attempting to use an ineligible key will
+ * result in a {@link org.apache.jdo.model.ModelException}. This means
+ * the specified key is of an inappropriate type for this
+ * JavaModelFactory or if the key is <code>null</code> and this
+ * JavaModelFactory does not support <code>null</code> keys.
+ * @param key the key that may be used to cache the returned JavaModel instance.
+ * @return a new JavaModel instance.
+ * @exception ModelException if impossible; the key is of an
+ * inappropriate type or the key is <code>null</code> and this
+ * JavaModelFactory does not support <code>null</code> keys.
+ */
+ abstract public JavaModel createJavaModel(Object key)
+ throws ModelException;
+
+ /**
+ * Returns the JavaModel instance for the specified key.
+ * <p>
+ * The method throws a {@link org.apache.jdo.model.ModelFatalException},
+ * if the specified key is of an inappropriate type for this
+ * JavaModelFactory or if the key is <code>null</code> and this
+ * JavaModelFactory does not support <code>null</code> keys.
+ * @param key the key used to cache the returned JavaModel instance.
+ * @return a JavaModel instance for the specified key.
+ * @exception ModelFatalException the key is of an inappropriate type
+ * or the key is <code>null</code> and this JavaModelFactory does not
+ * support <code>null</code> keys.
+ */
+ public JavaModel getJavaModel(Object key)
+ {
+ synchronized (this.modelCache) {
+ JavaModel javaModel = (JavaModel)modelCache.get(key);
+ if (javaModel == null) {
+ // create new model and store it using the specified key
+ try {
+ javaModel = createJavaModel(key);
+ modelCache.put(key, javaModel);
+ // get the corresponding JDOModel
+ JDOModel jdoModel =
+ getJDOModelFactory().getJDOModel(javaModel);
+ // update the JDOModel property of the JavaModel
+ javaModel.setJDOModel(jdoModel);
+ }
+ catch (ModelException ex) {
+ throw new ModelFatalException(
+ "EXC_CannotCreateJavaModel", ex); //NOI18N
+ }
+ }
+ return javaModel;
+ }
+ }
+
+ /**
+ * Returns a JavaType instance for the specified type description
+ * (optional operation). This method is a convenience method and a
+ * short cut for <code>getJavaModel(key).getJavaType(typeName)</code>.
+ * If the factory supports this method, it needs to be able to get the
+ * key for the JavaModel lookup and the type name for the JavaType
+ * lookup from the specified typeDesc. An example for such a type
+ * description is the java.lang.Class instance in the runtime
+ * environment.
+ * <p>
+ * The method throws a {@link org.apache.jdo.model.ModelFatalException},
+ * if this factory does not support this short cut or if it does not
+ * support the specified type description.
+ * <p>
+ * This implementation always throws a ModelFatalException.
+ * @param typeDesc the type description.
+ * @return a JavaType instance for the specified type.
+ * @exception ModelFatalException this factory does not support this
+ * short cut or does not support the specified type description.
+ */
+ public JavaType getJavaType(Object typeDesc)
+ {
+ throw new ModelFatalException(msg.msg(
+ "EXC_MethodNotSupported", this.getClass().getName(), //NOI18N
+ "getJavaType")); //NOI18N
+ }
+
+ //========= Internal helper methods ==========
+
+ /**
+ * Returns the JDOModelFactory instance used to get/create JDOModel
+ * instances.
+ * @return JDOModelFactory instance.
+ */
+ protected JDOModelFactory getJDOModelFactory()
+ {
+ return JDOModelFactoryImplDynamic.getInstance();
+ }
+}
+
Added: incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/model/java/AbstractJavaType.java
URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/model/java/AbstractJavaType.java?view=auto&rev=158176
==============================================================================
--- incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/model/java/AbstractJavaType.java (added)
+++ incubator/jdo/trunk/ri11/src/java/org/apache/jdo/impl/model/java/AbstractJavaType.java Fri Mar 18 17:02:29 2005
@@ -0,0 +1,110 @@
+/*
+ * 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.impl.model.java;
+
+import org.apache.jdo.model.java.JavaField;
+import org.apache.jdo.model.java.JavaType;
+import org.apache.jdo.model.jdo.JDOClass;
+
+
+/**
+ * Abstract super class for JavaType implementations. It provides a
+ * default implementation for all methods except getName. The methods return
+ * the Java default value of the return type.
+ * <p>
+ * A non-abstract subclass must implement method {@link #getName()} and
+ * needs to override any of the other methods where the default
+ * implementation is not appropriate.
+ * <p>
+ * Note, the class implements methods {@link #equals(Object obj)},
+ * {@link #hashCode()} and {@link #toString()}using the name of a JavaType.
+ *
+ * @author Michael Bouschen
+ * @since JDO 1.0.1
+ */
+abstract public class AbstractJavaType
+ implements JavaType
+{
+ public boolean isPrimitive() { return false; }
+ public boolean isIntegral() { return false; }
+ public boolean isFloatingPoint() { return false; }
+ public boolean isInterface() { return false; }
+ public boolean isArray() { return false; }
+ public boolean isWrapperClass() { return false; }
+ public boolean isJDOSupportedCollection() { return false; }
+ public boolean isJDOSupportedMap() { return false; }
+ public boolean isTrackable() { return false; }
+ public boolean isValue() { return false; }
+ public boolean isOrderable() { return false; }
+ public boolean isPersistenceCapable() { return false; }
+ public boolean isCompatibleWith(JavaType javaType) { return false; }
+ abstract public String getName();
+ public int getModifiers() { return 0; }
+ public JavaType getSuperclass() { return null; }
+ public JDOClass getJDOClass() { return null; }
+ public JavaType getArrayComponentType() { return null; }
+ public JavaField getJavaField(String name) { return null; }
+
+ // ===== Methods not defined in JavaType =====
+
+ /**
+ * Indicates whether some other object is "equal to" this one.
+ * @param obj the reference object with which to compare.
+ * <p>
+ * This implementation compares the name of the specified object to be
+ * equal to the name of this JavaType.
+ * this
+ * @return <code>true</code> if this object is the same as the obj
+ * argument; <code>false</code> otherwise.
+ */
+ public boolean equals(Object obj)
+ {
+ // return true if obj is this
+ if (obj == this) return true;
+ // return false if obj does not have the correct type
+ if ((obj == null) || !(obj instanceof JavaType)) return false;
+
+ JavaType other = (JavaType)obj;
+ // compare names
+ String name = getName();
+ if (name == null) return other.getName() == null;
+ return name.equals(other.getName());
+ }
+
+ /**
+ * Returns a hash code value for the object.
+ * <p>
+ * This implementation returns the hashCode of the name of this
+ * JavaType.
+ * @return a hash code value for this object.
+ */
+ public int hashCode()
+ {
+ String name = getName();
+ return (name == null) ? 0 : name.hashCode();
+ }
+
+ /**
+ * Returns a string representation of the object.
+ * @return a string representation of the object.
+ */
+ public String toString()
+ {
+ return getName();
+ }
+
+}
|