geronimo-scm mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From djen...@apache.org
Subject svn commit: r723243 [1/2] - /geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/
Date Thu, 04 Dec 2008 08:42:19 GMT
Author: djencks
Date: Thu Dec  4 00:42:18 2008
New Revision: 723243

URL: http://svn.apache.org/viewvc?rev=723243&view=rev
Log:
GERONIMO-4410 apply patch from Jeremy Bauer that removes javadoc mistakenly included as it was copied from Sun sourced documentation

Modified:
    geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/Aggregate.java
    geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/Cache.java
    geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/CaseExpression.java
    geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/DomainObject.java
    geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/EntityManager.java
    geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/EntityManagerFactory.java
    geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/Expression.java
    geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/FetchJoinObject.java
    geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/MapKeyColumn.java
    geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/PathExpression.java
    geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/Predicate.java
    geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/PredicateOperand.java
    geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/Query.java
    geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/QueryBuilder.java
    geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/QueryDefinition.java
    geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/SelectItem.java
    geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/Subquery.java
    geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/TrimSpec.java

Modified: geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/Aggregate.java
URL: http://svn.apache.org/viewvc/geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/Aggregate.java?rev=723243&r1=723242&r2=723243&view=diff
==============================================================================
--- geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/Aggregate.java (original)
+++ geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/Aggregate.java Thu Dec  4 00:42:18 2008
@@ -24,13 +24,6 @@
 //
 package javax.persistence;
 
-/**
- * Type of the result of an aggregate operation
- */
 public interface Aggregate extends Expression {
-    /**
-     * Specify that duplicates are to be removed before the aggregate operation
-     * is invoked.
-     */
     Expression distinct();
 }

Modified: geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/Cache.java
URL: http://svn.apache.org/viewvc/geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/Cache.java?rev=723243&r1=723242&r2=723243&view=diff
==============================================================================
--- geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/Cache.java (original)
+++ geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/Cache.java Thu Dec  4 00:42:18 2008
@@ -24,30 +24,12 @@
 //
 package javax.persistence;
 
-/**
- * Interface used to interact with the second-level cache.
- * If a cache is not in use, the methods of this interface have
- * no effect, except for contains, which returns false.
- */
 public interface Cache {
-    /**
-     * Whether the cache contains data for the given entity.
-     */
     public boolean contains(Class cls, Object primaryKey);
 
-    /**
-     * Remove the data for the given entity from the cache.
-     */
     public void evict(Class cls, Object primaryKey);
 
-    /**
-     * Remove the data for entities of the specified class (and its
-     * subclasses) from the cache.
-     */
     public void evict(Class cls);
 
-    /**
-     * Clear the cache.
-     */
     public void evictAll();
 }

Modified: geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/CaseExpression.java
URL: http://svn.apache.org/viewvc/geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/CaseExpression.java?rev=723243&r1=723242&r2=723243&view=diff
==============================================================================
--- geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/CaseExpression.java (original)
+++ geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/CaseExpression.java Thu Dec  4 00:42:18 2008
@@ -27,279 +27,48 @@
 import java.util.Calendar;
 import java.util.Date;
 
-/**
- * Interface for the construction of case expressions
- */
 public interface CaseExpression {
-    /**
-     * Add a when predicate clause to a general case expression. The when
-     * predicate must be followed by the corresponding then case expression that
-     * specifies the result of the specific case. Clauses are evaluated in the
-     * order added.
-     *
-     * @param pred -
-     *             corresponds to the evaluation condition for the specific case
-     * @return CaseExpression corresponding to the case with the added when
-     *         clause
-     */
     CaseExpression when(Predicate pred);
 
-    /**
-     * Add a when clause to a simple case expression. The when case expression
-     * must be followed by the corresponding then case expression that specifies
-     * the result of the specific case. Clauses are evaluated in the order added
-     *
-     * @param when -
-     *             corresponds to the value against which the case operand of the
-     *             simple case is tested
-     * @return CaseExpression corresponding to the case with the added clause
-     */
     CaseExpression when(Expression when);
 
-    /**
-     * Add a when clause to a simple case expression. The when case expression
-     * must be followed by the corresponding then case expression that specifies
-     * the result of the specific case. Clauses are evaluated in the order added
-     *
-     * @param when -
-     *             corresponds to the value against which the case operand of the
-     *             simple case is tested
-     * @return CaseExpression corresponding to the case with the added clause
-     */
     CaseExpression when(Number when);
 
-    /**
-     * Add a when clause to a simple case expression. The when case expression
-     * must be followed by the corresponding then case expression that specifies
-     * the result of the specific case. Clauses are evaluated in the order added
-     *
-     * @param when -
-     *             corresponds to the value against which the
-     *             case operand of the simple case is tested
-     * @return CaseExpression corresponding to the case with the added clause
-     */
     CaseExpression when(String when);
 
-    /**
-     * Add a when clause to a simple case expression. The when case expression
-     * must be followed by the corresponding then case expression that specifies
-     * the result of the specific case. Clauses are evaluated in the order added
-     *
-     * @param when -
-     *             corresponds to the value against which the case operand of the
-     *             simple case is tested
-     * @return CaseExpression corresponding to the case with the added clause
-     */
     CaseExpression when(Date when);
 
-    /**
-     * Add a when clause to a simple case expression. The when case expression
-     * must be followed by the corresponding then case expression that specifies
-     * the result of the specific case. Clauses are evaluated in the order added
-     *
-     * @param when -
-     *             corresponds to the value against which the case operand of the
-     *             simple case is tested
-     * @return CaseExpression corresponding to the case with the added clause
-     */
     CaseExpression when(Calendar when);
 
-    /**
-     * Add a when clause to a simple case expression. The when case expression
-     * must be followed by the corresponding then case expression that specifies
-     * the result of the specific case. Clauses are evaluated in the order added
-     *
-     * @param when -
-     *             corresponds to the value against which the case operand of the
-     *             simple case is tested
-     * @return CaseExpression corresponding to the case with the added clause
-     */
     CaseExpression when(Class when);
 
-    /**
-     * Add a when clause to a simple case expression. The when case expression
-     * must be followed by the corresponding then case expression that specifies
-     * the result of the specific case. Clauses are evaluated in the order added
-     *
-     * @param when -
-     *             corresponds to the value against which the case operand of the
-     *             simple case is tested
-     * @return CaseExpression corresponding to the case with the added clause
-     */
     CaseExpression when(Enum<?> when);
 
-    /**
-     * Add a then clause to a general or simple case expression. The then clause
-     * specifies the result corresponding to the immediately preceding when.
-     * Clauses are evaluated in the order added.
-     *
-     * @param then -
-     *             corresponds to the result of the case expression if the when
-     *             is satisfied
-     * @return CaseExpression corresponding to the case with the added then
-     *         clause
-     */
     CaseExpression then(Expression then);
 
-    /**
-     * Add a then clause to a general or simple case expression. The then clause
-     * specifies the result corresponding to the immediately preceding when.
-     * Clauses are evaluated in the order added.
-     *
-     * @param then -
-     *             corresponds to the result of the case expression if the when
-     *             is satisfied
-     * @return CaseExpression corresponding to the case with the added then
-     *         clause
-     */
     CaseExpression then(Number then);
 
-    /**
-     * Add a then clause to a general or simple case expression. The then clause
-     * specifies the result corresponding to the immediately preceding when.
-     * Clauses are evaluated in the order added.
-     *
-     * @param then -
-     *             corresponds to the result of the case expression if the when
-     *             is satisfied
-     * @return CaseExpression corresponding to the case with the added then
-     *         clause
-     */
     CaseExpression then(String then);
 
-    /**
-     * Add a then clause to a general or simple case expression. The then clause
-     * specifies the result corresponding to the immediately preceding when.
-     * Clauses are evaluated in the order added.
-     *
-     * @param then -
-     *             corresponds to the result of the case expression if the when
-     *             is satisfied
-     * @return CaseExpression corresponding to the case with the added then
-     *         clause
-     */
     CaseExpression then(Date then);
 
-    /**
-     * Add a then clause to a general or simple case expression. The then clause
-     * specifies the result corresponding to the immediately preceding when.
-     * Clauses are evaluated in the order added.
-     *
-     * @param then -
-     *             corresponds to the result of the case expression if the when
-     *             is satisfied
-     * @return CaseExpression corresponding to the case with the added then
-     *         clause
-     */
     CaseExpression then(Calendar then);
 
-    /**
-     * Add a then clause to a general or simple case expression. The then clause
-     * specifies the result corresponding to the immediately preceding when.
-     * Clauses are evaluated in the order added.
-     *
-     * @param then -
-     *             corresponds to the result of the case expression if the when
-     *             is satisfied
-     * @return CaseExpression corresponding to the case with the added then
-     *         clause
-     */
     CaseExpression then(Class then);
 
-    /**
-     * Add a then clause to a general or simple case expression. The then clause
-     * specifies the result corresponding to the immediately preceding when.
-     * Clauses are evaluated in the order added.
-     *
-     * @param then -
-     *             corresponds to the result of the case expression if the when
-     *             is satisfied
-     * @return CaseExpression corresponding to the case with the added then
-     *         clause
-     */
     CaseExpression then(Enum<?> then);
 
-    /**
-     * Add else to a case expression. A case expression must have an else
-     * clause.
-     *
-     * @param arg -
-     *            corresponds to the result of the case expression if the when
-     *            condition is not satisfied
-     * @return Expression corresponding to the case expression with the added
-     *         clause
-     */
     Expression elseCase(Expression arg);
 
-    /**
-     * Add else to a case expression. A case expression must have an else
-     * clause.
-     *
-     * @param arg -
-     *            corresponds to the result of the case expression if the when
-     *            condition is not satisfied
-     * @return Expression corresponding to the case expression with the added
-     *         clause
-     */
     Expression elseCase(String arg);
 
-    /**
-     * Add else to a case expression. A case expression must have an else
-     * clause.
-     *
-     * @param arg -
-     *            corresponds to the result of the case expression if the when
-     *            condition is not satisfied
-     * @return Expression corresponding to the case expression with the added
-     *         clause
-     */
     Expression elseCase(Number arg);
 
-    /**
-     * Add else to a case expression. A case expression must have an else
-     * clause.
-     *
-     * @param arg -
-     *            corresponds to the result of the case expression if the when
-     *            condition is not satisfied
-     * @return Expression corresponding to the case expression with the added
-     *         clause
-     */
     Expression elseCase(Date arg);
 
-    /**
-     * Add else to a case expression. A case expression must have an else
-     * clause.
-	 *
-	 * @param arg -
-	 *            corresponds to the result of the case expression if the when
-	 *            condition is not satisfied
-	 * @return Expression corresponding to the case expression with the added
-	 *         clause
-	 */
 	Expression elseCase(Calendar arg);
 
-	/**
-	 * Add else to a case expression. A case expression must have an else
-	 * clause.
-	 *
-	 * @param arg -
-	 *            corresponds to the result of the case expression if the when
-	 *            condition is not satisfied
-	 * @return Expression corresponding to the case expression with the added
-	 *         clause
-	 */
 	Expression elseCase(Class arg);
 
-	/**
-	 * Add else to a case expression. A case expression must have an else
-	 * clause.
-	 *
-	 * @param arg -
-	 *            corresponds to the result of the case expression if the when
-	 *            condition is not satisfied
-	 * @return Expression corresponding to the case expression with the added
-	 *         clause
-	 */
 	Expression elseCase(Enum<?> arg);
 }

Modified: geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/DomainObject.java
URL: http://svn.apache.org/viewvc/geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/DomainObject.java?rev=723243&r1=723242&r2=723243&view=diff
==============================================================================
--- geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/DomainObject.java (original)
+++ geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/DomainObject.java Thu Dec  4 00:42:18 2008
@@ -24,106 +24,20 @@
 //
 package javax.persistence;
 
-/**
- * Domain objects define the domain over which a query operates. A domain object
- * plays a role analogous to that of a Java Persistence query language
- * identification variable.
- */
 public interface DomainObject extends PathExpression, QueryDefinition {
-    /**
-     * Extend the query domain by joining with a class that can be navigated to
-     * or that is embedded in the class corresponding to the domain object on
-     * which the method is invoked. This method is permitted to be invoked only
-     * when defining the domain of the query. It must not be invoked within the
-     * context of the select, where, groupBy, or having operations. The domain
-     * object must correspond to a class that contains the referenced attribute.
-     * The query definition is modified to include the newly joined domain
-     * object.
-     *
-     * @param attribute -
-     *                  name of the attribute that references the target of the join
-     * @return the new DomainObject that is added for the target of the join
-     */
     DomainObject join(String attribute);
 
-    /**
-     * Extend the query domain by left outer joining with a class that can be
-     * navigated to or that is embedded in the class corresponding to the domain
-     * object on which the method is invoked. This method is permitted to be
-     * invoked only when defining the domain of the query. It must not be
-     * invoked within the context of the select, where, groupBy, or having
-     * operations. The domain object must correspond to a class that contains
-     * the referenced attribute. The query definition is modified to include the
-     * newly joined domain object.
-     *
-     * @param attribute -
-     *                  name of the attribute that references the target of the join
-     * @return the new DomainObject that is added for the target of the join
-     */
     DomainObject leftJoin(String attribute);
 
-    /**
-     * Specify that the association or element collection that is referenced by
-     * the attribute be eagerly fetched through use of an inner join. The domain
-     * object must correspond to a class that contains the referenced attribute.
-     * The query is modified to include the joined domain object.
-     *
-     * @param attribute -
-     *                  name of the attribute that references the target of the join
-     * @return the FetchJoinObject that is added for the target of the join
-     */
     FetchJoinObject joinFetch(String attribute);
 
-    /**
-     * Specify that the association or element collection that is referenced by
-     * the attribute be eagerly fetched through use of a left outer join. The
-     * domain object must correspond to a class that contains the referenced
-     * attribute. The query is modified to include the joined domain object.
-     *
-     * @param attribute -
-     *                  name of the attribute that references the target of the join
-     * @return the FetchJoinObject that is added for the target of the join
-     */
     FetchJoinObject leftJoinFetch(String attribute);
 
-    /**
-     * Return a path expression corresponding to the value of a map-valued
-     * association or element collection. This method is only permitted to be
-     * invoked upon a domain object that corresponds to a map-valued association
-     * or element collection.
-     *
-     * @return PathExpression corresponding to the map value
-     */
     PathExpression value();
 
-    /**
-     * Return a path expression corresponding to the key of a map-valued
-     * association or element collection. This method is only permitted to be
-     * invoked upon a domain object that corresponds to a map-valued association
-     * or element collection.
-     *
-     * @return PathExpression corresponding to the map key
-     */
     PathExpression key();
 
-    /**
-     * Return a select item corresponding to the map entry of a map-valued
-     * association or element collection. This method is only permitted to be
-     * invoked upon a domain object that corresponds to a map-valued association
-     * or element collection.
-     *
-     * @return SelectItem corresponding to the map entry
-     */
     SelectItem entry();
 
-    /**
-     * Return an expression that corresponds to the index. of the domain object
-     * in the referenced association or element collection. This method is only
-	 * permitted to be invoked upon a domain object that corresponds to a
-	 * multi-valued association or element collection for which an order column
-	 * has been defined.
-	 *
-	 * @return Expression denoting the index
-	 */
 	Expression index();
 }

Modified: geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/EntityManager.java
URL: http://svn.apache.org/viewvc/geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/EntityManager.java?rev=723243&r1=723242&r2=723243&view=diff
==============================================================================
--- geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/EntityManager.java (original)
+++ geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/EntityManager.java Thu Dec  4 00:42:18 2008
@@ -28,595 +28,84 @@
 import java.util.Set;
 
 /**
- * Interface used to interact with the persistence context.
- *
  * @version $Rev$ $Date$
  */
 public interface EntityManager {
 
-    /**
-     * Make an instance managed and persistent.
-     *
-     * @param entity
-     * @throws EntityExistsException        if the entity already exists.
-     *                                      (The EntityExistsException may be thrown when the persist
-     *                                      operation is invoked, or the EntityExistsException or
-     *                                      another PersistenceException may be thrown at flush or
-     *                                      commit time.)
-     * @throws IllegalArgumentException     if the instance is not an
-     *                                      entity
-     * @throws TransactionRequiredException if invoked on a
-     *                                      container-managed entity manager of type
-     *                                      PersistenceContextType.TRANSACTION and there is
-     *                                      no transaction.
-     */
     public void persist(Object entity);
 
-    /**
-     * Merge the state of the given entity into the
-     * current persistence context.
-     *
-     * @param entity
-     * @return the managed instance that the state was merged to
-     * @throws IllegalArgumentException     if instance is not an
-     *                                      entity or is a removed entity
-     * @throws TransactionRequiredException if invoked on a
-     *                                      container-managed entity manager of type
-     *                                      PersistenceContextType.TRANSACTION and there is
-     *                                      no transaction.
-     */
     public <T> T merge(T entity);
 
-    /**
-     * Remove the entity instance.
-     *
-     * @param entity
-     * @throws IllegalArgumentException     if the instance is not an
-     *                                      entity or is a detached entity
-     * @throws TransactionRequiredException if invoked on a
-     *                                      container-managed entity manager of type
-     *                                      PersistenceContextType.TRANSACTION and there is
-     *                                      no transaction.
-     */
     public void remove(Object entity);
 
-    /**
-     * Find by primary key.
-     * Search for an entity of the specified class and primary key.
-     * If the entity instance is contained in the persistence context
-     * it is returned from there.
-     *
-     * @param entityClass
-     * @param primaryKey
-     * @return the found entity instance or null
-     *         if the entity does not exist
-     * @throws IllegalArgumentException if the first argument does
-     *                                  not denote an entity type or the second argument is
-     *                                  is not a valid type for that entity’s primary key or
-     *                                  is null
-     */
     public <T> T find(Class<T> entityClass, Object primaryKey);
 
-    /**
-     * Find by primary key and lock.
-     * Search for an entity of the specified class and primary key
-     * and lock it with respect to the specified lock type.
-     * If the entity instance is contained in the persistence context
-     * it is returned from there, and the effect of this method is
-     * the same as if the lock method had been called on the entity.
-     * If the entity is found within the persistence context and the
-     * lock mode type is pessimistic and the entity has a version
-     * attribute, the persistence provider must perform optimistic
-     * version checks when obtaining the database lock. If these
-     * checks fail, the OptimisticLockException will be thrown.
-     * If the lock mode type is pessimistic and the entity instance
-     * is found but cannot be locked:
-     * - the PessimisticLockException will be thrown if the database
-     * locking failure causes transaction-level rollback.
-     * - the LockTimeoutException will be thrown if the database
-     * locking failure causes only statement-level rollback
-     *
-     * @param entityClass
-     * @param primaryKey
-     * @param lockMode
-     * @return the found entity instance or null if the entity does
-     *         not exist
-     * @throws IllegalArgumentException     if the first argument does
-     *                                      not denote an entity type or the second argument is
-     *                                      not a valid type for that entity's primary key or
-     *                                      is null
-     * @throws TransactionRequiredException if there is no
-     *                                      transaction and a lock mode other than NONE is set
-     * @throws OptimisticLockException      if the optimistic version
-     *                                      check fails
-     * @throws PessimisticLockException     if pessimistic locking
-     *                                      fails and the transaction is rolled back
-     * @throws LockTimeoutException         if pessimistic locking fails and
-     *                                      only the statement is rolled back
-     * @throws PersistenceException         if an unsupported lock call
-     *                                      is made
-     */
     public <T> T find(Class<T> entityClass, Object primaryKey,
                       LockModeType lockMode);
 
-    /**
-     * Find by primary key and lock, using specified properties.
-     * Search for an entity of the specified class and primary key
-     * and lock it with respect to the specified lock type.
-     * If the entity instance is contained in the persistence context
-     * it is returned from there. If the entity is found
-     * within the persistence context and the lock mode type
-     * is pessimistic and the entity has a version attribute, the
-     * persistence provider must perform optimistic version checks
-     * when obtaining the database lock. If these checks fail,
-     * the OptimisticLockException will be thrown.
-     * If the lock mode type is pessimistic and the entity instance
-     * is found but cannot be locked:
-     * - the PessimisticLockException will be thrown if the database
-     * locking failure causes transaction-level rollback.
-     * - the LockTimeoutException will be thrown if the database
-     * locking failure causes only statement-level rollback
-     * If a vendor-specific property or hint is not recognized,
-     * it is silently ignored.
-     * Portable applications should not rely on the standard timeout
-     * hint. Depending on the database in use and the locking
-     * mechanisms used by the provider, the hint may or may not
-     * be observed.
-     *
-     * @param entityClass
-     * @param primaryKey
-     * @param lockMode
-     * @param properties  standard and vendor-specific properties
-     *                    and hints
-     * @return the found entity instance or null if the entity does
-     *         not exist
-     * @throws IllegalArgumentException     if the first argument does
-     *                                      not denote an entity type or the second argument is
-     *                                      not a valid type for that entity's primary key or
-     *                                      is null
-     * @throws TransactionRequiredException if there is no
-     *                                      transaction and a lock mode other than NONE is set
-     * @throws OptimisticLockException      if the optimistic version
-     *                                      check fails
-     * @throws PessimisticLockException     if pessimistic locking
-     *                                      fails and the transaction is rolled back
-     * @throws LockTimeoutException         if pessimistic locking fails and
-     *                                      only the statement is rolled back
-     * @throws PersistenceException         if an unsupported lock call
-     *                                      is made
-     */
     public <T> T find(Class<T> entityClass, Object primaryKey,
                       LockModeType lockMode,
                       Map<String, Object> properties);
 
-    /**
-     * Get an instance, whose state may be lazily fetched.
-     * If the requested instance does not exist in the database,
-     * the EntityNotFoundException is thrown when the instance
-     * state is first accessed. (The persistence provider runtime is
-     * permitted to throw the EntityNotFoundException when
-     * getReference is called.)
-     * The application should not expect that the instance state will
-     * be available upon detachment, unless it was accessed by the
-     * application while the entity manager was open.
-     *
-     * @param entityClass
-     * @param primaryKey
-     * @return the found entity instance
-     * @throws IllegalArgumentException if the first argument does
-     *                                  not denote an entity type or the second argument is
-     *                                  not a valid type for that entity’s primary key or
-     *                                  is null
-     * @throws EntityNotFoundException  if the entity state
-     *                                  cannot be accessed
-     */
     public <T> T getReference(Class<T> entityClass, Object primaryKey);
 
-    /**
-     * Synchronize the persistence context to the
-     * underlying database.
-     *
-     * @throws TransactionRequiredException if there is
-     *                                      no transaction
-     * @throws PersistenceException         if the flush fails
-     */
     public void flush();
 
-    /**
-     * Set the flush mode that applies to all objects contained
-     * in the persistence context.
-     *
-     * @param flushMode
-     */
     public void setFlushMode(FlushModeType flushMode);
 
-    /**
-     * Get the flush mode that applies to all objects contained
-     * in the persistence context.
-     *
-     * @return flushMode
-     */
     public FlushModeType getFlushMode();
 
-    /**
-     * Lock an entity instance that is contained in the persistence
-     * context with the specified lock mode type.
-     * If a pessimistic lock mode type is specified and the entity
-     * contains a version attribute, the persistence provider must
-     * also perform optimistic version checks when obtaining the
-     * database lock. If these checks fail, the
-     * OptimisticLockException will be thrown.
-     * If the lock mode type is pessimistic and the entity instance
-     * is found but cannot be locked:
-     * - the PessimisticLockException will be thrown if the database
-     * locking failure causes transaction-level rollback.
-     * - the LockTimeoutException will be thrown if the database
-     * locking failure causes only statement-level rollback
-     *
-     * @param entity
-     * @param lockMode
-     * @throws IllegalArgumentException     if the instance is not an
-     *                                      entity or is a detached entity
-     * @throws TransactionRequiredException if there is no
-     *                                      transaction
-     * @throws EntityNotFoundException      if the entity does not exist
-     *                                      in the database when pessimistic locking is
-     *                                      performed
-     * @throws OptimisticLockException      if the optimistic version
-     *                                      check fails
-     * @throws PessimisticLockException     if pessimistic locking fails
-     *                                      and the transaction is rolled back
-     * @throws LockTimeoutException         if pessimistic locking fails and
-     *                                      only the statement is rolled back
-     * @throws PersistenceException         if an unsupported lock call
-     *                                      is made
-     */
     public void lock(Object entity, LockModeType lockMode);
 
-    /**
-     * Lock an entity instance that is contained in the persistence
-     * context with the specified lock mode type and with specified
-     * properties.
-     * If a pessimistic lock mode type is specified and the entity
-     * contains a version attribute, the persistence provider must
-     * also perform optimistic version checks when obtaining the
-     * database lock. If these checks fail, the
-     * OptimisticLockException will be thrown.
-     * If the lock mode type is pessimistic and the entity instance
-     * is found but cannot be locked:
-     * - the PessimisticLockException will be thrown if the database
-     * locking failure causes transaction-level rollback.
-     * - the LockTimeoutException will be thrown if the database
-     * locking failure causes only statement-level rollback
-     * If a vendor-specific property or hint is not recognized,
-     * it is silently ignored.
-     * Portable applications should not rely on the standard timeout
-     * hint. Depending on the database in use and the locking
-     * mechanisms used by the provider, the hint may or may not
-     * be observed.
-     *
-     * @param entity
-     * @param lockMode
-     * @param properties standard and vendor-specific properties
-     *                   and hints
-     * @throws IllegalArgumentException     if the instance is not an
-     *                                      entity or is a detached entity
-     * @throws TransactionRequiredException if there is no
-     *                                      transaction
-     * @throws EntityNotFoundException      if the entity does not exist
-     *                                      in the database when pessimistic locking is
-     *                                      performed
-     * @throws OptimisticLockException      if the optimistic version
-     *                                      check fails
-     * @throws PessimisticLockException     if pessimistic locking fails
-     *                                      and the transaction is rolled back
-     * @throws LockTimeoutException         if pessimistic locking fails and
-     *                                      only the statement is rolled back
-     * @throws PersistenceException         if an unsupported lock call
-     *                                      is made
-     */
     public void lock(Object entity, LockModeType lockMode,
                      Map<String, Object> properties);
 
-    /**
-     * Refresh the state of the instance from the database,
-     * overwriting changes made to the entity, if any.
-     *
-     * @param entity
-     * @throws IllegalArgumentException     if the instance is not
-     *                                      an entity or the entity is not managed
-     * @throws TransactionRequiredException if invoked on a
-     *                                      container-managed entity manager of type
-     *                                      PersistenceContextType.TRANSACTION and there is
-     *                                      no transaction.
-     * @throws EntityNotFoundException      if the entity no longer
-     *                                      exists in the database
-     */
     public void refresh(Object entity);
 
-    /**
-     * Refresh the state of the instance from the database,
-     * overwriting changes made to the entity, if any, and
-     * lock it with respect to given lock mode type.
-     * If the lock mode type is pessimistic and the entity instance
-     * is found but cannot be locked:
-     * - the PessimisticLockException will be thrown if the database
-     * locking failure causes transaction-level rollback.
-     * - the LockTimeoutException will be thrown if the
-     * database locking failure causes only statement-level
-     * rollback.
-     *
-     * @param entity
-     * @param lockMode
-     * @throws IllegalArgumentException     if the instance is not
-     *                                      an entity or the entity is not managed
-     * @throws TransactionRequiredException if there is no
-     *                                      transaction
-     * @throws EntityNotFoundException      if the entity no longer exists
-     *                                      in the database
-     * @throws PessimisticLockException     if pessimistic locking fails
-     *                                      and the transaction is rolled back
-     * @throws LockTimeoutException         if pessimistic locking fails and
-     *                                      only the statement is rolled back
-     * @throws PersistenceException         if an unsupported lock call
-     *                                      is made
-     */
     public void refresh(Object entity, LockModeType lockMode);
 
-    /**
-     * Refresh the state of the instance from the database,
-     * overwriting changes made to the entity, if any, and
-     * lock it with respect to given lock mode type and with
-     * specified properties.
-     * If the lock mode type is pessimistic and the entity instance
-     * is found but cannot be locked:
-     * - the PessimisticLockException will be thrown if the database
-     * locking failure causes transaction-level rollback.
-     * - the LockTimeoutException will be thrown if the database
-     * locking failure causes only statement-level rollback
-     * If a vendor-specific property or hint is not recognized,
-     * it is silently ignored.
-     * Portable applications should not rely on the standard timeout
-     * hint. Depending on the database in use and the locking
-     * mechanisms used by the provider, the hint may or may not
-     * be observed.
-     *
-     * @param entity
-     * @param lockMode
-     * @param properties standard and vendor-specific properties
-     *                   and hints
-     * @throws IllegalArgumentException     if the instance is not
-     *                                      an entity or the entity is not managed
-     * @throws TransactionRequiredException if there is no
-     *                                      transaction
-     * @throws EntityNotFoundException      if the entity no longer exists
-     *                                      in the database
-     * @throws PessimisticLockException     if pessimistic locking fails
-     *                                      and the transaction is rolled back
-     * @throws LockTimeoutException         if pessimistic locking fails and
-     *                                      only the statement is rolled back
-     * @throws PersistenceException         if an unsupported lock call
-     *                                      is made
-     */
     public void refresh(Object entity, LockModeType lockMode,
                         Map<String, Object> properties);
 
-    /**
-     * Clear the persistence context, causing all managed
-     * entities to become detached. Changes made to entities that
-     * have not been flushed to the database will not be
-     * persisted.
-     */
     public void clear();
 
-    /**
-     * Remove the given entity from the persistence context, causing
-     * a managed entity to become detached. Unflushed changes made
-     * to the entity if any (including removal of the entity),
-     * will not be synchronized to the database.
-     *
-     * @param entity
-     * @throws IllegalArgumentException if the instance is not an
-     *                                  entity
-     */
     public void clear(Object entity);
 
-    //    Open Issue: Alternative names for this method and the corresponding cascade option.
-    /**
-     * Check if the instance is a managed entity instance belonging
-     * to the current persistence context.
-     *
-     * @param entity
-     * @return
-     * @throws IllegalArgumentException if not an entity
-     */
     public boolean contains(Object entity);
 
-    /**
-     * Get the current lock mode for the entity instance.
-     *
-     * @param entity
-     * @return lock mode
-     * @throws TransactionRequiredException if there is no
-     *                                      transaction
-     * @throws IllegalArgumentException     if the instance is not a
-     *                                      managed entity and a transaction is active
-     */
     public LockModeType getLockMode(Object entity);
 
-    /**
-     * Get the properties and associated values that are in effect
-     * for the entity manager. Changing the contents of the map does
-     * not change the configuration in effect.
-     */
     public Map<String, Object> getProperties();
 
-    /**
-     * Get the names of the properties that are supported for use
-     * with the entity manager.
-     * These correspond to properties and hints that may be passed
-     * to the methods of the EntityManager interface that take a
-     * properties argument or used with the PersistenceContext
-     * annotation. These properties include all standard entity
-     * manager hints and properties as well as vendor-specific ones
-     * supported by the provider. These properties may or may not
-     * currently be in effect.
-     *
-     * @return property names
-     */
     public Set<String> getSupportedProperties();
 
-    /**
-     * Create an instance of Query for executing a
-     * Java Persistence query language statement.
-     *
-     * @param qlString a Java Persistence query string
-     * @return the new query instance
-     * @throws IllegalArgumentException if the query string is found
-     *                                  to be invalid
-     */
     public Query createQuery(String qlString);
 
-    /**
-     * Create an instance of Query for executing a
-     * criteria query.
-     *
-     * @param qdef a Criteria API query definition object
-     * @return the new query instance
-     * @throws IllegalArgumentException if the query definition is
-     *                                  found to be invalid
-     */
     public Query createQuery(QueryDefinition qdef);
 
-    /**
-     * Create an instance of Query for executing a
-     * named query (in the Java Persistence query language
-     * or in native SQL).
-     *
-     * @param name the name of a query defined in metadata
-     * @return the new query instance
-     * @throws IllegalArgumentException if a query has not been
-     *                                  defined with the given name or if the query string is
-     *                                  found to be invalid
-     */
     public Query createNamedQuery(String name);
 
-    /**
-     * Create an instance of Query for executing
-     * a native SQL statement, e.g., for update or delete.
-     *
-     * @param sqlString a native SQL query string
-     * @return the new query instance
-     */
     public Query createNativeQuery(String sqlString);
 
-    /**
-     * Create an instance of Query for executing
-     * a native SQL query.
-     *
-     * @param sqlString   a native SQL query string
-     * @param resultClass the class of the resulting instance(s)
-     * @return the new query instance
-     */
     public Query createNativeQuery(String sqlString,
                                    Class resultClass);
 
-    /**
-     * Create an instance of Query for executing
-     * a native SQL query.
-     *
-     * @param sqlString        a native SQL query string
-     * @param resultSetMapping the name of the result set mapping
-     * @return the new query instance
-     */
     public Query createNativeQuery(String sqlString,
                                    String resultSetMapping);
 
-    /**
-     * Indicate to the EntityManager that a JTA transaction is
-     * active. This method should be called on a JTA application
-     * managed EntityManager that was created outside the scope
-     * of the active transaction to associate it with the current
-     * JTA transaction.
-     *
-     * @throws TransactionRequiredException if there is
-     *                                      no transaction.
-     */
     public void joinTransaction();
 
-    /**
-     * Return an object of the specified type to allow access to the
-     * provider-specific API. If the provider's EntityManager
-     * implementation does not support the specified class, the
-     * PersistenceException is thrown.
-     *
-     * @param cls the class of the object to be returned. This is
-     *            normally either the underlying EntityManager implementation
-     *            class or an interface that it implements.
-     * @return an instance of the specified class
-     * @throws PersistenceException if the provider does not
-     *                              support the call.
-     */
     public <T> T unwrap(Class<T> cls);
 
-    /**
-     * Return the underlying provider object for the EntityManager,
-     * if available. The result of this method is implementation
-     * specific. The unwrap method is to be preferred for new
-     * applications.
-     */
     public Object getDelegate();
 
-    /**
-     * Close an application-managed EntityManager.
-     * After the close method has been invoked, all methods
-     * on the EntityManager instance and any Query objects obtained
-     * from it will throw the IllegalStateException except
-     * for getProperties, getSupportedProperties, getTransaction,
-     * and isOpen (which will return false).
-     * If this method is called when the EntityManager is
-     * associated with an active transaction, the persistence
-     * context remains managed until the transaction completes.
-     *
-     * @throws IllegalStateException if the EntityManager
-     *                               is container-managed.
-     */
     public void close();
 
-    /**
-     * Determine whether the EntityManager is open.
-     *
-     * @return true until the EntityManager has been closed.
-     */
     public boolean isOpen();
 
-    /**
-     * Return the resource-level transaction object.
-     * The EntityTransaction instance may be used serially to
-     * begin and commit multiple transactions.
-     *
-     * @return EntityTransaction instance
-     * @throws IllegalStateException if invoked on a JTA
-     *                               EntityManager.
-     */
     public EntityTransaction getTransaction();
 
-    /**
-     * Return the entity manager factory for the entity manager.
-     *
-     * @return EntityManagerFactory instance
-     * @throws IllegalStateException if the entity manager has
-     *                               been closed.
-     */
     public EntityManagerFactory getEntityManagerFactory();
 
-    /**
-     * Return an instance of QueryBuilder for the creation of
-     * Criteria API QueryDefinition objects.
-     *
-     * @return QueryBuilder instance
-     * @throws IllegalStateException if the entity manager has
-     *                               been closed.
-     */
     public QueryBuilder getQueryBuilder();
 }

Modified: geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/EntityManagerFactory.java
URL: http://svn.apache.org/viewvc/geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/EntityManagerFactory.java?rev=723243&r1=723242&r2=723243&view=diff
==============================================================================
--- geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/EntityManagerFactory.java (original)
+++ geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/EntityManagerFactory.java Thu Dec  4 00:42:18 2008
@@ -28,94 +28,24 @@
 import java.util.Set;
 
 /**
- * Interface used to interact with the entity manager factory
- * for the persistence unit.
  *
  * @version $Rev$ $Date$
  */
 public interface EntityManagerFactory {
 
-    /**
-     * Create a new EntityManager.
-     * This method returns a new EntityManager instance each time
-     * it is invoked.
-     * The isOpen method will return true on the returned instance.
-     *
-     * @throws IllegalStateException if the entity manager factory
-     *                               has been closed.
-     */
     public EntityManager createEntityManager();
 
-    /**
-     * Create a new EntityManager with the specified Map of
-     * properties.
-     * This method returns a new EntityManager instance each time
-     * it is invoked.
-     * The isOpen method will return true on the returned instance.
-     *
-     * @throws IllegalStateException if the entity manager factory
-     *                               has been closed.
-     */
     public EntityManager createEntityManager(Map map);
 
-    /**
-     * Return an instance of QueryBuilder for the creation of
-     * Criteria API QueryDefinition objects.
-     *
-     * @return QueryBuilder instance
-     * @throws IllegalStateException if the entity manager factory
-     *                               has been closed.
-     */
     public QueryBuilder getQueryBuilder();
 
-    /**
-     * Close the factory, releasing any resources that it holds.
-     * After a factory instance is closed, all methods invoked on
-     * it will throw an IllegalStateException, except for isOpen,
-     * which will return false. Once an EntityManagerFactory has
-     * been closed, all its entity managers are considered to be
-     * in the closed state.
-     *
-     * @throws IllegalStateException if the entity manager factory
-     *                               has been closed.
-     */
     public void close();
 
-    /**
-     * Indicates whether the factory is open. Returns true
-     * until the factory has been closed.
-     */
     public boolean isOpen();
 
-    /**
-     * Get the properties and associated values that are in effect
-     * for the entity manager factory. Changing the contents of the
-     * map does not change the configuration in effect.
-     *
-     * @return properties
-     */
     public Map getProperties();
 
-    /**
-     * Get the names of the properties that are supported for use
-     * with the entity manager factory. These correspond to
-     * properties that may be passed to the methods of the
-     * EntityManagerFactory interface that take a properties
-     * argument. These include all standard properties as well as
-     * vendor-specific properties supported by the provider. These
-     * properties may or may not currently be in effect.
-     *
-     * @return properties and hints
-     */
     public Set<String> getSupportedProperties();
 
-    /**
-     * Access the cache that is associated with the entity manager
-     * factory (the "second level cache").
-     *
-     * @return instance of the Cache interface
-     * @throws IllegalStateException if the entity manager factory
-     *                               has been closed.
-     */
     public Cache getCache();
 }

Modified: geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/Expression.java
URL: http://svn.apache.org/viewvc/geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/Expression.java?rev=723243&r1=723242&r2=723243&view=diff
==============================================================================
--- geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/Expression.java (original)
+++ geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/Expression.java Thu Dec  4 00:42:18 2008
@@ -24,507 +24,93 @@
 //
 package javax.persistence;
 
-/**
- * Instances of this interface can be used either as select list items or as
- * predicate operands.
- */
 public interface Expression extends SelectItem, PredicateOperand {
-    /*
-         * Conditional predicates over expression items
-         */
-    /**
-     * Create a predicate for testing whether the expression is a member of the
-     * association or element collection denoted by the path expression. The
-     * argument must correspond to a collection-valued association or element
-     * collection of like type.
-     *
-     * @param arg -
-     *            a path expression that specifies a collection-valued
-     *            association or an element collection
-     * @return conditional predicate
-     */
+
     Predicate member(PathExpression arg);
 
-    /**
-     * Create a predicate for testing whether the value of the expression is
-     * null.
-     *
-     * @return conditional predicate
-     */
     Predicate isNull();
 
-    /**
-     * Create a predicate for testing whether the expression value is a member
-     * of the argument list.
-     *
-     * @param strings
-     * @return conditional predicate
-     */
     Predicate in(String... strings);
 
-    /**
-     * Create a predicate for testing whether the expression value is a member
-     * of the argument list.
-     *
-     * @param nums
-     * @return conditional predicate
-     */
     Predicate in(Number... nums);
 
-    /**
-     * Create a predicate for testing whether the expression value is a member
-     * of the argument list.
-     *
-     * @param enums
-     * @return conditional predicate
-     */
     Predicate in(Enum<?>... enums);
 
-    /**
-     * Create a predicate for testing whether the expression value is a member
-     * of the argument list.
-     *
-     * @param classes
-     * @return conditional predicate
-     */
     Predicate in(Class... classes);
 
-    /**
-     * Create a predicate for testing whether the expression value is a member
-     * of the argument list.
-     *
-     * @param params
-     * @return conditional predicate
-     */
     Predicate in(Expression... params);
 
-    /**
-     * Create a predicate for testing whether the expression value is a member
-     * of a subquery result.
-     *
-     * @param subquery
-     * @return conditional predicate
-     */
     Predicate in(Subquery subquery);
 
-    /*
-         * Operations on strings
-         */
-    /**
-     * String length This method must be invoked on an expression corresponding
-     * to a string.
-     *
-     * @return expression denoting the length of the string.
-     */
     Expression length();
 
-    /**
-     * Concatenate a string with other string(s). This method must be invoked on
-     * an expression corresponding to a string.
-     *
-     * @param str -
-     *            string(s)
-     * @return expression denoting the concatenation of the strings, starting
-     *         with the string corresponding to the expression on which the
-     *         method was invoked.
-     */
     Expression concat(String... str);
 
-    /**
-     * Concatenate a string with other string(s). This method must be invoked on
-     * an expression corresponding to a string.
-     *
-     * @param str -
-     *            expression(s) corresponding to string(s)
-     * @return expression denoting the concatenation of the strings, starting
-     *         with the string corresponding to the expression on which the
-     *         method was invoked.
-     */
     Expression concat(Expression... str);
 
-    /**
-     * Extract a substring starting at specified position through to the end of
-     * the string. This method must be invoked on an expression corresponding to
-     * a string.
-     *
-     * @param start -
-     *              start position (1 indicates first position)
-     * @return expression denoting the extracted substring
-     */
     Expression substring(int start);
 
-    /**
-     * Extract a substring starting at specified position through to the end of
-     * the string. This method must be invoked on an expression corresponding to
-     * a string.
-     *
-     * @param start -
-     *              expression denoting start position (1 indicates first
-     *              position)
-     * @return expression denoting the extracted substring
-     */
     Expression substring(Expression start);
 
-    /**
-     * Extract a substring. This method must be invoked on an expression
-     * corresponding to a string.
-     *
-     * @param start -
-     *              start position (1 indicates first position)
-     * @param len   -
-     *              length of the substring to be returned
-     * @return expression denoting the extracted substring
-     */
     Expression substring(int start, int len);
 
-    /**
-     * Extract a substring. This method must be invoked on an expression
-     * corresponding to a string.
-     *
-     * @param start -
-     *              start position (1 indicates first position)
-     * @param len   -
-     *              expression denoting length of the substring to return
-     * @return expression denoting the extracted substring
-     */
     Expression substring(int start, Expression len);
 
-    /**
-     * Extract a substring. This method must be invoked on an expression
-     * corresponding to a string.
-     *
-     * @param start -
-     *              expression denoting start position (1 indicates first
-     *              position)
-     * @param len   -
-     *              length of the substring to return
-     * @return expression denoting the extracted substring
-     */
     Expression substring(Expression start, int len);
 
-    /**
-     * Extract a substring. This method must be invoked on an expression
-     * corresponding to a string.
-     *
-     * @param start -
-     *              expression denoting start position (1 indicates first
-     *              position)
-     * @param len   -
-     *              expression denoting length of the substring to return
-     * @return expression denoting the extracted substring
-     */
     Expression substring(Expression start, Expression len);
 
-    /**
-     * Convert string to lowercase. This method must be invoked on an expression
-     * corresponding to a string.
-     *
-     * @return expression denoting the string in lowercase
-     */
     Expression lower();
 
-    /**
-     * Convert string to uppercase. This method must be invoked on an expression
-     * corresponding to a string.
-     *
-     * @return expression denoting the string in uppercase
-     */
     Expression upper();
 
-    /**
-     * Trim leading and trailing blanks. This method must be invoked on an
-     * expression corresponding to a string.
-     *
-     * @return expression denoting trimmed string
-     */
     Expression trim();
 
-    /**
-     * Trim leading, trailing blanks (or both) as specified by trim spec. This
-     * method must be invoked on an expression corresponding to a string.
-     *
-     * @param spec -
-     *             trim specification
-     * @return expression denoting trimmed string
-     */
     Expression trim(TrimSpec spec);
 
-    /**
-     * Trim leading and trailing occurrences of character from the string. This
-     * method must be invoked on an expression corresponding to a string.
-     *
-     * @param c -
-     *          character to be trimmed
-     * @return expression denoting trimmed string
-     */
     Expression trim(char c);
 
-    /**
-     * Trim occurrences of the character from leading or trailing (or both)
-     * positions of the string, as specified by trim spec. This method must be
-     * invoked on an expression corresponding to a string.
-     *
-     * @param c    -
-     *             character to be trimmed
-     * @param spec -
-     *             trim specification
-     * @return expression denoting trimmed string
-     */
     Expression trim(char c, TrimSpec spec);
 
-    /**
-     * Trim leading and trailing occurrences of character specified by the
-     * expression argument from the string. This method must be invoked on an
-     * expression corresponding to a string.
-     *
-     * @param expr -
-     *             expression corresponding to the character to be trimmed
-     * @return expression denoting trimmed string
-     */
     Expression trim(Expression expr);
 
-    /**
-     * Trim occurrences of the character specified by the expression argument
-     * from leading or trailing (or both) positions of the string, as specified
-     * by trim spec. This method must be invoked on an expression corresponding
-     * to a string.
-     *
-     * @param expr -
-     *             expression corresponding to the character to be trimmed
-     * @param spec -
-     *             trim specification
-     * @return expression denoting trimmed string
-     */
     Expression trim(Expression expr, TrimSpec spec);
 
-    /**
-     * Locate a string contained within the string corresponding to the
-     * expression on which the method was invoked. The search is started at
-     * position 1 (first string position). This method must be invoked on an
-     * expression corresponding to a string.
-     *
-     * @param str -
-     *            string to be located
-     * @return expression denoting the first position at which the string was
-     *         found or expression denoting 0 if the string was not found
-     */
     Expression locate(String str);
 
-    /**
-     * Locate a string contained within the string corresponding to the
-     * expression on which the method was invoked. The search is started at
-     * position 1 (first string position). This method must be invoked on an
-     * expression corresponding to a string.
-     *
-     * @param str -
-     *            expression corresponding to the string to be located
-     * @return expression denoting the first position at which the string was
-     *         found or expression denoting 0 if the string was not found
-     */
     Expression locate(Expression str);
 
-    /**
-     * Locate a string contained within the string corresponding to the
-     * expression on which the method was invoked, starting at a specified
-     * search position. This method must be invoked on an expression
-     * corresponding to a string.
-     *
-     * @param str      -
-     *                 string to be located
-     * @param position -
-     *                 position at which to start the search
-     * @return expression denoting the first position at which the string was
-     *         found or expression denoting 0 if the string was not found
-     */
     Expression locate(String str, int position);
 
-    /**
-     * Locate a string contained within the string corresponding to the
-     * expression on which the method was invoked, starting at a specified
-     * search position. This method must be invoked on an expression
-     * corresponding to a string.
-     *
-     * @param str      -
-     *                 string to be located
-     * @param position -
-     *                 expression corresponding to position at which to start the
-     *                 search
-     * @return expression denoting the first position at which the string was
-     *         found or expression denoting 0 if the string was not found
-     */
     Expression locate(String str, Expression position);
 
-    /**
-     * Locate a string contained within the string corresponding to the
-     * expression on which the method was invoked, starting at a specified
-     * search position. This method must be invoked on an expression
-     * corresponding to a string.
-     *
-     * @param str      -
-     *                 expression corresponding to the string to be located
-     * @param position -
-     *                 position at which to start the search
-     * @return expression denoting the first position at which the string was
-     *         found or expression denoting 0 if the string was not found
-     */
     Expression locate(Expression str, int position);
 
-    /**
-     * Locate a string contained within the string corresponding to the
-     * expression on which the method was invoked, starting at a specified
-     * search position. This method must be invoked on an expression
-     * corresponding to a string.
-     *
-     * @param str      -
-     *                 expression corresponding to the string to be located
-     * @param position -
-     *                 expression corresponding to position at which to start the
-     *                 search
-     * @return expression denoting the first position at which the string was
-     *         found or expression denoting 0 if the string was not found
-     */
     Expression locate(Expression str, Expression position);
 
-    /*
-         * Arithmetic operations
-         */
-    /**
-     * Addition. This method must be invoked on an expression corresponding to a
-     * number.
-     *
-     * @param num -
-     *            number to be added
-     * @return expression denoting the sum
-     */
     Expression plus(Number num);
 
-    /**
-     * Addition. This method must be invoked on an expression corresponding to a
-     * number.
-     *
-     * @param expr -
-     *             expression corresponding to number to be added
-     * @return expression denoting the sum
-     */
     Expression plus(Expression expr);
 
-    /**
-     * Unary minus. This method must be invoked on an expression corresponding
-     * to a number.
-     *
-     * @return expression denoting the unary minus of the expression
-     */
     Expression minus();
 
-    /**
-     * Subtraction. This method must be invoked on an expression corresponding
-     * to a number.
-     *
-     * @param num -
-     *            subtrahend
-     * @return expression denoting the result of subtracting the argument from
-     *         the number corresponding to the expression on which the method
-     *         was invoked.
-     */
     Expression minus(Number num);
 
-    /**
-     * Subtraction. This method must be invoked on an expression corresponding
-     * to a number.
-     *
-     * @param expr -
-     *             expression corresponding to subtrahend
-     * @return expression denoting the result of subtracting the number denoted
-     *         by the argument from the number corresponding to the expression
-     *         on which the method was invoked.
-     */
     Expression minus(Expression expr);
 
-    /**
-     * Division. This method must be invoked on an expression corresponding to a
-     * number.
-     *
-     * @param num -
-     *            divisor
-     * @return expression denoting the result of dividing the number
-     *         corresponding to the expression on which the method was invoked
-     *         by the argument
-     */
     Expression dividedBy(Number num);
 
-    /**
-     * Division. This method must be invoked on an expression corresponding to a
-     * number.
-     *
-     * @param expr -
-     *             expression corresponding to the divisor
-     * @return expression denoting the result of dividing the number
-     *         corresponding to the expression on which the method was invoked
-     *         by the number denoted by the argument
-     */
     Expression dividedBy(Expression expr);
 
-    /**
-     * Multiplication. This method must be invoked on an expression
-     * corresponding to a number.
-     *
-     * @param num -
-     *            multiplier
-     * @return expression denoting the result of multiplying the argument with
-     *         the number corresponding to the expression on which the method
-     *         was invoked.
-     */
     Expression times(Number num);
 
-    /**
-     * Multiplication. This method must be invoked on an expression
-     * corresponding to a number.
-     *
-     * @param expr -
-     *             expression corresponding to the multiplier
-     * @return expression denoting the result of multiplying the number denoted
-     *         by the argument with the number corresponding to the expression
-     *         on which the method was invoked.
-         */
 	Expression times(Expression expr);
 
-	/**
-	 * Absolute value. This method must be invoked on an expression
-	 * corresponding to a number.
-	 *
-	 * @return expression corresponding to the absolute value
-	 */
 	Expression abs();
 
-	/**
-	 * Square root. This method must be invoked on an expression corresponding
-	 * to a number.
-	 *
-	 * @return expression corresponding to the square root
-	 */
 	Expression sqrt();
 
-	/**
-	 * Modulo operation. This must be invoked on an expression corresponding to
-	 * an integer value
-	 *
-	 * @param num -
-	 *            integer divisor
-	 * @return expression corresponding to the integer remainder of the division
-	 *         of the integer corresponding to the expression on which the
-	 *         method was invoked by the argument.
-	 */
 	Expression mod(int num);
 
-	/**
-         * Modulo operation. This must be invoked on an expression corresponding to
-         * an integer value
-         *
-         * @param expr -
-         *             expression corresponding to integer divisor
-         * @return expression corresponding to the integer remainder of the division
-         *         of the integer corresponding to the expression on which the
-         *         method was invoked by the argument.
-         */
 	Expression mod(Expression expr);
-}
\ No newline at end of file
+}

Modified: geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/FetchJoinObject.java
URL: http://svn.apache.org/viewvc/geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/FetchJoinObject.java?rev=723243&r1=723242&r2=723243&view=diff
==============================================================================
--- geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/FetchJoinObject.java (original)
+++ geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/FetchJoinObject.java Thu Dec  4 00:42:18 2008
@@ -24,8 +24,5 @@
 //
 package javax.persistence;
 
-/**
- * Interface used for the result of a fetch join.
- */
 public interface FetchJoinObject {
 }

Modified: geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/MapKeyColumn.java
URL: http://svn.apache.org/viewvc/geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/MapKeyColumn.java?rev=723243&r1=723242&r2=723243&view=diff
==============================================================================
--- geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/MapKeyColumn.java (original)
+++ geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/MapKeyColumn.java Thu Dec  4 00:42:18 2008
@@ -48,7 +48,7 @@
 
     int length() default 255;
 
-    int precision() default 0; // decimal precision
+    int precision() default 0;
 
-    int scale() default 0; // decimal scale
+    int scale() default 0;
 }

Modified: geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/PathExpression.java
URL: http://svn.apache.org/viewvc/geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/PathExpression.java?rev=723243&r1=723242&r2=723243&view=diff
==============================================================================
--- geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/PathExpression.java (original)
+++ geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/PathExpression.java Thu Dec  4 00:42:18 2008
@@ -24,99 +24,23 @@
 //
 package javax.persistence;
 
-/**
- * Interface for operations over objects reached via paths
- */
 public interface PathExpression extends Expression {
-    /**
-     * Return a path expression corresponding to the referenced attribute. It is
-     * not permitted to invoke this method on a path expression that corresponds
-     * to a multi-valued association or element collection. The path expression
-     * on which this method is invoked must correspond to a class containing the
-     * referenced attribute.
-     *
-     * @param attributeName -
-     *                      name of the referenced attribute
-     * @return path expression
-     */
+
     PathExpression get(String attributeName);
 
-    /**
-     * Return an expression that corresponds to the type of the entity. This
-     * method can only be invoked on a path expression corresponding to an
-     * entity. It is not permitted to invoke this method on a path expression
-     * that corresponds to a multi-valued association.
-     *
-     * @return expression denoting the entity's type
-     */
     Expression type();
 
-    /**
-     * Return an expression that corresponds to the number of elements
-     * association or element collection corresponding to the path expression.
-     * This method can only be invoked on a path expression that corresponds to
-     * a multi-valued association or to an element collection.
-     *
-     * @return expression denoting the size
-     */
     Expression size();
 
-    /**
-     * Add a restriction that the path expression must correspond to an
-     * association or element collection that is empty (has no elements). This
-     * method can only be invoked on a path expression that corresponds to a
-     * multi-valued association or to an element collection.
-     *
-     * @return predicate corresponding to the restriction
-     */
     Predicate isEmpty();
 
-    /**
-     * Specify that the avg operation is to be applied. The path expression must
-     * correspond to an attribute of a numeric type. It is not permitted to
-     * invoke this method on a path expression that corresponds to a
-     * multi-valued association or element collection.
-     *
-     * @return the resulting aggregate
-     */
     Aggregate avg();
 
-    /**
-     * Specify that the max operation is to be applied. The path expression must
-     * correspond to an attribute of an orderable type. It is not permitted to
-     * invoke this method on a path expression that corresponds to a
-     * multi-valued association or element collection.
-     *
-     * @return the resulting aggregate
-     */
     Aggregate max();
 
-    /**
-     * Specify that the min operation is to be applied. The path expression must
-     * correspond to an attribute of an orderable type. It is not permitted to
-     * invoke this method on a path expression that corresponds to a
-     * multi-valued association or element collection.
-     *
-     * @return the resulting aggregate
-     */
     Aggregate min();
 
-    /**
-     * Specify that the count operation is to be applied. It is not permitted to
-     * invoke this method on a path expression that corresponds to a
-     * multi-valued association or element collection.
-     *
-     * @return the resulting aggregate
-     */
     Aggregate count();
 
-    /**
-     * Specify that the sum operation is to be applied. The path expression must
-     * correspond to an attribute of a numeric type. It is not permitted to
-     * invoke this method on a path expression that corresponds to a
-     * multi-valued association or element collection.
-	 *
-	 * @return the resulting aggregate
-	 */
 	Aggregate sum();
-}
\ No newline at end of file
+}

Modified: geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/Predicate.java
URL: http://svn.apache.org/viewvc/geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/Predicate.java?rev=723243&r1=723242&r2=723243&view=diff
==============================================================================
--- geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/Predicate.java (original)
+++ geronimo/specs/trunk/geronimo-jpa_2.0_spec/src/main/java/javax/persistence/Predicate.java Thu Dec  4 00:42:18 2008
@@ -24,35 +24,11 @@
 //
 package javax.persistence;
 
-/**
- * Interface used to define compound predicates.
- */
 public interface Predicate {
-    /**
-     * Creates an AND of the predicate with the argument.
-     *
-     * @param predicate -
-     *                  A simple or compound predicate
-     * @return the predicate that is the AND of the original simple or compound
-     *         predicate and the argument.
-     */
+
     Predicate and(Predicate predicate);
 
-    /**
-     * Creates an OR of the predicate with the argument.
-     *
-     * @param predicate -
-     *                  A simple or compound predicate
-     * @return the predicate that is the OR of the original simple or compound
-     *         predicate and the argument.
-     */
     Predicate or(Predicate predicate);
 
-    /**
-     * Creates a negation of the predicate with the argument.
-     *
-     * @return the predicate that is the negation of the original simple or
-	 *         compound predicate.
-	 */
 	Predicate not();
-}
\ No newline at end of file
+}



Mime
View raw message