Added support for dynamic entities

10 files changed, 219 insertions, 17 deletions

diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/GenericJpaJpqlQueryHelper.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/GenericJpaJpqlQueryHelper.java
index 17647069b8..da1d382742 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/GenericJpaJpqlQueryHelper.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/GenericJpaJpqlQueryHelper.java
@@ -16,6 +16,8 @@ package org.eclipse.jpt.jpa.core.internal;
 import org.eclipse.jpt.jpa.core.context.AttributeMapping;
 import org.eclipse.jpt.jpa.core.jpql.JpaJpqlQueryHelper;
 import org.eclipse.jpt.jpa.core.jpql.spi.GenericMappingBuilder;
+import org.eclipse.jpt.jpa.core.jpql.spi.IManagedTypeBuilder;
+import org.eclipse.jpt.jpa.core.jpql.spi.JpaManagedTypeBuilder;
 import org.eclipse.persistence.jpa.jpql.AbstractContentAssistVisitor;
 import org.eclipse.persistence.jpa.jpql.AbstractGrammarValidator;
 import org.eclipse.persistence.jpa.jpql.AbstractSemanticValidator;
@@ -74,6 +76,14 @@ public class GenericJpaJpqlQueryHelper extends JpaJpqlQueryHelper {
 	 * {@inheritDoc}
 	 */
 	@Override
+	protected IManagedTypeBuilder buildManagedTypeBuilder() {
+		return new JpaManagedTypeBuilder();
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	@Override
 	protected IMappingBuilder<AttributeMapping> buildMappingBuilder() {
 		return new GenericMappingBuilder();
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/jpql/JpaJpqlQueryHelper.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/jpql/JpaJpqlQueryHelper.java
index 0b1c7ee76f..99597f448c 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/jpql/JpaJpqlQueryHelper.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/jpql/JpaJpqlQueryHelper.java
@@ -14,7 +14,6 @@
 package org.eclipse.jpt.jpa.core.jpql;
 
 import java.util.List;
-
 import org.eclipse.core.resources.IResource;
 import org.eclipse.jpt.common.core.internal.utility.SimpleTextRange;
 import org.eclipse.jpt.common.core.utility.TextRange;
@@ -25,6 +24,7 @@ import org.eclipse.jpt.jpa.core.context.persistence.PersistenceUnit;
 import org.eclipse.jpt.jpa.core.internal.prefs.JpaValidationPreferencesManager;
 import org.eclipse.jpt.jpa.core.internal.validation.DefaultJpaValidationMessages;
 import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
+import org.eclipse.jpt.jpa.core.jpql.spi.IManagedTypeBuilder;
 import org.eclipse.jpt.jpa.core.jpql.spi.JpaManagedTypeProvider;
 import org.eclipse.jpt.jpa.core.jpql.spi.JpaQuery;
 import org.eclipse.persistence.jpa.jpql.AbstractJPQLQueryHelper;
@@ -55,7 +55,7 @@ import org.eclipse.wst.validation.internal.provisional.core.IMessage;
  * to solicit feedback from pioneering adopters on the understanding that any code that uses this
  * API will almost certainly be broken (repeatedly) as the API evolves.
  *
- * @version 3.1
+ * @version 3.2
  * @since 3.0
  * @author Pascal Filion
  */
@@ -77,6 +77,20 @@ public abstract class JpaJpqlQueryHelper extends AbstractJPQLQueryHelper {
 		super(jpqlGrammar);
 	}
 
+	/**
+	 * Create the builder that will create the right implementation of {@link org.eclipse.persistence.
+	 * jpa.jpql.spi.IManagedType IManagedType}.
+	 *
+	 * @return A new {@link IMappingBuilder}
+	 */
+	protected abstract IManagedTypeBuilder buildManagedTypeBuilder();
+
+	/**
+	 * Create the builder that will create the right implementation of {@link org.eclipse.persistence.
+	 * jpa.jpql.spi.IMapping IMapping}.
+	 *
+	 * @return A new {@link IMappingBuilder}
+	 */
 	protected abstract IMappingBuilder<AttributeMapping> buildMappingBuilder();
 
 	/**
@@ -177,7 +191,12 @@ public abstract class JpaJpqlQueryHelper extends AbstractJPQLQueryHelper {
 	 * @return A new {@link JpaManagedTypeProvider}
 	 */
 	protected JpaManagedTypeProvider buildProvider(JpaProject jpaProject, PersistenceUnit persistenceUnit) {
-		return new JpaManagedTypeProvider(jpaProject, persistenceUnit, buildMappingBuilder());
+		return new JpaManagedTypeProvider(
+			jpaProject,
+			persistenceUnit,
+			buildManagedTypeBuilder(),
+			buildMappingBuilder()
+		);
 	}
 
 	protected int getValidationPreference(NamedQuery namedQuery) {
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/jpql/spi/IManagedTypeBuilder.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/jpql/spi/IManagedTypeBuilder.java
new file mode 100644
index 0000000000..2b5727df35
--- /dev/null
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/jpql/spi/IManagedTypeBuilder.java
@@ -0,0 +1,67 @@
+/*******************************************************************************
+ * Copyright (c) 2012 Oracle. All rights reserved.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
+ * which accompanies this distribution.
+ * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *     Oracle - initial API and implementation
+ *
+ ******************************************************************************/
+package org.eclipse.jpt.jpa.core.jpql.spi;
+
+import org.eclipse.jpt.jpa.core.context.AttributeMapping;
+import org.eclipse.jpt.jpa.core.context.Embeddable;
+import org.eclipse.jpt.jpa.core.context.Entity;
+import org.eclipse.jpt.jpa.core.context.MappedSuperclass;
+import org.eclipse.persistence.jpa.jpql.spi.IEmbeddable;
+import org.eclipse.persistence.jpa.jpql.spi.IEntity;
+import org.eclipse.persistence.jpa.jpql.spi.IMappedSuperclass;
+import org.eclipse.persistence.jpa.jpql.spi.IMappingBuilder;
+
+/**
+ * @version 3.2
+ * @since 3.2
+ * @author Pascal Filion
+ */
+public interface IManagedTypeBuilder {
+
+	/**
+	 * Creates
+	 *
+	 * @param provider
+	 * @param mappedClass
+	 * @param mappingBuilder
+	 * @return
+	 */
+	IEmbeddable buildEmbeddable(JpaManagedTypeProvider provider,
+	                            Embeddable mappedClass,
+	                            IMappingBuilder<AttributeMapping> mappingBuilder);
+
+	/**
+	 * Creates
+	 *
+	 * @param provider
+	 * @param mappedClass
+	 * @param mappingBuilder
+	 * @return
+	 */
+	IEntity buildEntity(JpaManagedTypeProvider provider,
+	                    Entity mappedClass,
+	                    IMappingBuilder<AttributeMapping> mappingBuilder);
+
+	/**
+	 * Creates
+	 *
+	 * @param provider
+	 * @param mappedClass
+	 * @param mappingBuilder
+	 * @return
+	 */
+	IMappedSuperclass buildMappedSuperclass(JpaManagedTypeProvider provider,
+	                                        MappedSuperclass mappedClass,
+	                                        IMappingBuilder<AttributeMapping> mappingBuilder);
+}
\ No newline at end of file
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/jpql/spi/JpaEmbeddable.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/jpql/spi/JpaEmbeddable.java
index cd19c4dc92..053591f7d3 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/jpql/spi/JpaEmbeddable.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/jpql/spi/JpaEmbeddable.java
@@ -28,7 +28,7 @@ import org.eclipse.persistence.jpa.jpql.spi.IMappingBuilder;
  * to solicit feedback from pioneering adopters on the understanding that any code that uses this
  * API will almost certainly be broken (repeatedly) as the API evolves.
  *
- * @version 3.1
+ * @version 3.2
  * @since 3.0
  * @author Pascal Filion
  */
@@ -61,7 +61,7 @@ public class JpaEmbeddable extends JpaManagedType
 	 * {@inheritDoc}
 	 */
 	@Override
-	protected Embeddable getManagedType() {
+	public Embeddable getManagedType() {
 		return (Embeddable) super.getManagedType();
 	}
 
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/jpql/spi/JpaEntity.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/jpql/spi/JpaEntity.java
index 53d1b45800..94b5b25340 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/jpql/spi/JpaEntity.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/jpql/spi/JpaEntity.java
@@ -33,7 +33,7 @@ import org.eclipse.persistence.jpa.jpql.spi.IQuery;
  * to solicit feedback from pioneering adopters on the understanding that any code that uses this
  * API will almost certainly be broken (repeatedly) as the API evolves.
  *
- * @version 3.1
+ * @version 3.2
  * @since 3.0
  * @author Pascal Filion
  */
@@ -75,7 +75,7 @@ public class JpaEntity extends JpaManagedType
 	 * {@inheritDoc}
 	 */
 	@Override
-	protected Entity getManagedType() {
+	public Entity getManagedType() {
 		return (Entity) super.getManagedType();
 	}
 
@@ -94,6 +94,9 @@ public class JpaEntity extends JpaManagedType
 		return queries.get(queryName);
 	}
 
+	/**
+	 * Initializes the map JPQL queries if it has not been been initialized yet.
+	 */
 	protected void initializeQueries() {
 		if (queries == null) {
 			queries = new HashMap<String, IQuery>();
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/jpql/spi/JpaManagedType.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/jpql/spi/JpaManagedType.java
index e769866140..4d66656d88 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/jpql/spi/JpaManagedType.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/jpql/spi/JpaManagedType.java
@@ -121,7 +121,7 @@ public abstract class JpaManagedType implements IManagedType {
 	 *
 	 * @return The managed type wrapped by this external form
 	 */
-	protected TypeMapping getManagedType() {
+	public TypeMapping getManagedType() {
 		return managedType;
 	}
 
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/jpql/spi/JpaManagedTypeBuilder.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/jpql/spi/JpaManagedTypeBuilder.java
new file mode 100644
index 0000000000..d044b8d196
--- /dev/null
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/jpql/spi/JpaManagedTypeBuilder.java
@@ -0,0 +1,61 @@
+/*******************************************************************************
+ * Copyright (c) 2012 Oracle. All rights reserved.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
+ * which accompanies this distribution.
+ * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *     Oracle - initial API and implementation
+ *
+ ******************************************************************************/
+package org.eclipse.jpt.jpa.core.jpql.spi;
+
+import org.eclipse.jpt.jpa.core.context.AttributeMapping;
+import org.eclipse.jpt.jpa.core.context.Embeddable;
+import org.eclipse.jpt.jpa.core.context.Entity;
+import org.eclipse.jpt.jpa.core.context.MappedSuperclass;
+import org.eclipse.persistence.jpa.jpql.spi.IEmbeddable;
+import org.eclipse.persistence.jpa.jpql.spi.IEntity;
+import org.eclipse.persistence.jpa.jpql.spi.IMappedSuperclass;
+import org.eclipse.persistence.jpa.jpql.spi.IMappingBuilder;
+
+/**
+ * @version 3.2
+ * @since 3.2
+ * @author Pascal Filion
+ */
+public class JpaManagedTypeBuilder implements IManagedTypeBuilder {
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public IEmbeddable buildEmbeddable(JpaManagedTypeProvider provider,
+	                                   Embeddable mappedClass,
+	                                   IMappingBuilder<AttributeMapping> mappingBuilder) {
+
+		return new JpaEmbeddable(provider, mappedClass, mappingBuilder);
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public IEntity buildEntity(JpaManagedTypeProvider provider,
+	                           Entity mappedClass,
+	                           IMappingBuilder<AttributeMapping> mappingBuilder) {
+
+		return new JpaEntity(provider, mappedClass, mappingBuilder);
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public IMappedSuperclass buildMappedSuperclass(JpaManagedTypeProvider provider,
+	                                               MappedSuperclass mappedClass,
+	                                               IMappingBuilder<AttributeMapping> mappingBuilder) {
+
+		return new JpaMappedSuperclass(provider, mappedClass, mappingBuilder);
+	}
+}
\ No newline at end of file
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/jpql/spi/JpaManagedTypeProvider.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/jpql/spi/JpaManagedTypeProvider.java
index 9f1dc2dd22..2be773aa4a 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/jpql/spi/JpaManagedTypeProvider.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/jpql/spi/JpaManagedTypeProvider.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2011 Oracle. All rights reserved.
+ * Copyright (c) 2011, 2012 Oracle. All rights reserved.
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
  * which accompanies this distribution.
@@ -36,15 +36,15 @@ import org.eclipse.persistence.jpa.jpql.util.iterator.CloneIterator;
 import org.eclipse.persistence.jpa.jpql.util.iterator.IterableIterator;
 
 /**
- * The abstract implementation of {@link IManagedTypeProvider} that is wrapping the design-time
- * representation of a provider of managed types.
+ * An implementation of {@link IManagedTypeProvider} that is wrapping the design-time representation
+ * of a provider of managed types.
  *
  * Provisional API: This interface is part of an interim API that is still under development and
  * expected to change significantly before reaching stability. It is available at this early stage
  * to solicit feedback from pioneering adopters on the understanding that any code that uses this
  * API will almost certainly be broken (repeatedly) as the API evolves.
  *
- * @version 3.1
+ * @version 3.2
  * @since 3.0
  * @author Pascal Filion
  */
@@ -66,6 +66,11 @@ public class JpaManagedTypeProvider implements IManagedTypeProvider {
 	private final JpaProject jpaProject;
 
 	/**
+	 *
+	 */
+	private IManagedTypeBuilder managedTypeBuilder;
+
+	/**
 	 * The cached {@link IManagedType managed types}.
 	 */
 	private Map<String, IManagedType> managedTypes;
@@ -96,37 +101,63 @@ public class JpaManagedTypeProvider implements IManagedTypeProvider {
 	 *
 	 * @param jpaProject The project that gives access to the application's metadata
 	 * @param persistentTypeContainer The design-time provider of managed types
+	 * @param managedTypeBuilder
 	 * @param mappingBuilder The builder that is responsible to create the {@link IMapping} wrapping
 	 * a persistent attribute or property
 	 */
 	public JpaManagedTypeProvider(JpaProject jpaProject,
 	                              PersistentTypeContainer persistentTypeContainer,
+	                              IManagedTypeBuilder managedTypeBuilder,
 	                              IMappingBuilder<AttributeMapping> mappingBuilder) {
 
 		super();
 		this.jpaProject = jpaProject;
 		this.mappingBuilder = mappingBuilder;
+		this.managedTypeBuilder = managedTypeBuilder;
 		this.persistentTypeContainer = persistentTypeContainer;
 	}
 
+	/**
+	 * Creates a new <code>JpaManagedTypeProvider</code>.
+	 *
+	 * @param jpaProject The project that gives access to the application's metadata
+	 * @param persistentTypeContainer The design-time provider of managed types
+	 * @param mappingBuilder The builder that is responsible to create the {@link IMapping} wrapping
+	 * a persistent attribute or property
+	 */
+	public JpaManagedTypeProvider(JpaProject jpaProject,
+	                              PersistentTypeContainer persistentTypeContainer,
+	                              IMappingBuilder<AttributeMapping> mappingBuilder) {
+
+		this(jpaProject, persistentTypeContainer, new JpaManagedTypeBuilder(), mappingBuilder);
+	}
+
+	protected IEmbeddable buildEmbeddable(Embeddable mappedClass) {
+		return managedTypeBuilder.buildEmbeddable(this, mappedClass, mappingBuilder);
+	}
+
+	protected IEntity buildEntity(Entity mappedClass) {
+		return managedTypeBuilder.buildEntity(this, mappedClass, mappingBuilder);
+	}
+
 	protected IManagedType buildManagedType(PersistentType persistentType) {
 
 		TypeMapping mappedClass = persistentType.getMapping();
 
 		if (mappedClass instanceof Entity) {
-			JpaEntity entity = new JpaEntity(this, (Entity) mappedClass, mappingBuilder);
+			IEntity entity = buildEntity((Entity) mappedClass);
 			entities.add(entity);
 			return entity;
 		}
 
 		if (mappedClass instanceof MappedSuperclass) {
-			JpaMappedSuperclass mappedSuperclass = new JpaMappedSuperclass(this, (MappedSuperclass) mappedClass, mappingBuilder);
+			IMappedSuperclass mappedSuperclass = buildMappedSuperclass((MappedSuperclass) mappedClass);
 			mappedSuperclasses.add(mappedSuperclass);
 			return mappedSuperclass;
 		}
 
 		if (mappedClass instanceof Embeddable) {
-			JpaEmbeddable embeddable = new JpaEmbeddable(this, (Embeddable) mappedClass, mappingBuilder);
+			IEmbeddable embeddable = buildEmbeddable((Embeddable) mappedClass);
 			embeddables.add(embeddable);
 			return embeddable;
 		}
@@ -156,6 +187,10 @@ public class JpaManagedTypeProvider implements IManagedTypeProvider {
 		return managedTypes;
 	}
 
+	protected IMappedSuperclass buildMappedSuperclass(MappedSuperclass mappedClass) {
+		return managedTypeBuilder.buildMappedSuperclass(this, mappedClass, mappingBuilder);
+	}
+
 	/**
 	 * {@inheritDoc}
 	 */
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/jpql/spi/JpaMappedSuperclass.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/jpql/spi/JpaMappedSuperclass.java
index 17187cdd39..df99029c67 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/jpql/spi/JpaMappedSuperclass.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/jpql/spi/JpaMappedSuperclass.java
@@ -28,7 +28,7 @@ import org.eclipse.persistence.jpa.jpql.spi.IMappingBuilder;
  * to solicit feedback from pioneering adopters on the understanding that any code that uses this
  * API will almost certainly be broken (repeatedly) as the API evolves.
  *
- * @version 3.1
+ * @version 3.2
  * @since 3.0
  * @author Pascal Filion
  */
@@ -61,7 +61,7 @@ public class JpaMappedSuperclass extends JpaManagedType
 	 * {@inheritDoc}
 	 */
 	@Override
-	protected MappedSuperclass getManagedType() {
+	public MappedSuperclass getManagedType() {
 		return (MappedSuperclass) super.getManagedType();
 	}
 
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/jpql/spi/JpaMapping.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/jpql/spi/JpaMapping.java
index 92b40fe24f..d94b675a01 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/jpql/spi/JpaMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/jpql/spi/JpaMapping.java
@@ -95,9 +95,11 @@ public abstract class JpaMapping implements IMapping {
 	}
 
 	protected Iterable<ITypeDeclaration> buildGenericTypeDeclarations(JavaResourceAttribute resource) {
+
 		if (resource == null) {
 			return EmptyIterable.instance();
 		}
+
 		return new TransformationIterable<String, ITypeDeclaration>(resource.getTypeTypeArgumentNames()) {
 			@Override
 			protected ITypeDeclaration transform(String next) {
@@ -267,6 +269,11 @@ public abstract class JpaMapping implements IMapping {
 		return typeDeclaration;
 	}
 
+	/**
+	 * Returns the type repository for the application.
+	 *
+	 * @return The repository of {@link IType ITypes}
+	 */
 	protected ITypeRepository getTypeRepository() {
 		return parent.getProvider().getTypeRepository();
 	}