model framework changes necessary to support derived id's

57 files changed, 1665 insertions, 1364 deletions

diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/JpaPlatform.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/JpaPlatform.java
index 0f7a526c8b..2ca5005967 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/JpaPlatform.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/JpaPlatform.java
@@ -11,19 +11,12 @@ package org.eclipse.jpt.core;
 
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.runtime.content.IContentType;
-import org.eclipse.jpt.core.context.MappingFile;
-import org.eclipse.jpt.core.context.java.JavaAttributeMapping;
+import org.eclipse.jpt.core.context.MappingFileDefinition;
+import org.eclipse.jpt.core.context.java.JavaAttributeMappingProvider;
+import org.eclipse.jpt.core.context.java.NullDefaultJavaAttributeMappingProvider;
 import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;
 import org.eclipse.jpt.core.context.java.JavaPersistentType;
 import org.eclipse.jpt.core.context.java.JavaTypeMapping;
-import org.eclipse.jpt.core.context.orm.OrmAttributeMapping;
-import org.eclipse.jpt.core.context.orm.OrmPersistentAttribute;
-import org.eclipse.jpt.core.context.orm.OrmPersistentType;
-import org.eclipse.jpt.core.context.orm.OrmTypeMapping;
-import org.eclipse.jpt.core.context.persistence.MappingFileRef;
-import org.eclipse.jpt.core.resource.orm.XmlAttributeMapping;
-import org.eclipse.jpt.core.resource.orm.XmlTypeMapping;
-import org.eclipse.jpt.core.resource.xml.JpaXmlResource;
 import org.eclipse.jpt.core.utility.jdt.AnnotationEditFormatter;
 import org.eclipse.jpt.db.ConnectionProfileFactory;
 import org.eclipse.jpt.db.DatabaseFinder;
@@ -89,8 +82,8 @@ public interface JpaPlatform
 	AnnotationEditFormatter getAnnotationEditFormatter();
 
 
-	// ********** Java type mappings **********
-
+	// ********** Java type/attribute mappings **********
+	
 	/**
 	 * Build a Java type mapping for the specified key and persistent type.
 	 * Use identity when comparing keys; so clients must use the same key
@@ -99,7 +92,7 @@ public interface JpaPlatform
 	 * platform.
 	 */
 	JavaTypeMapping buildJavaTypeMappingFromMappingKey(String key, JavaPersistentType type);
-
+	
 	/**
 	 * Build a Java type mapping for the specified annotation and persistent
 	 * type. Use identity when comparing annotation names; so clients must
@@ -108,77 +101,50 @@ public interface JpaPlatform
 	 * supported by the platform.
 	 */
 	JavaTypeMapping buildJavaTypeMappingFromAnnotation(String annotationName, JavaPersistentType type);
-
-
-	// ********** Java attribute mappings **********
-
-	/**
-	 * Build a Java attribute mapping for the specified key and persistent attribute.
-	 * Use identity when comparing keys; so clients must use the same key
-	 * constants as the providers.
-	 * Throw an IllegalArgumentException if the key is not supported by the
-	 * platform.
-	 */
-	JavaAttributeMapping buildJavaAttributeMappingFromMappingKey(String key, JavaPersistentAttribute attribute);
-
-	/**
-	 * Build a Java attribute mapping for the specified annotation and persistent
-	 * attribute. Use identity when comparing annotation names; so clients must
-	 * use the same name constants as the providers.
-	 * Throw an IllegalArgumentException if the mapping annotation is not
-	 * supported by the platform.
-	 */
-	JavaAttributeMapping buildJavaAttributeMappingFromAnnotation(String annotationName, JavaPersistentAttribute attribute);
-
-	/**
-	 * Build a default Java attribute mapping for the specified persistent attribute.
-	 */
-	JavaAttributeMapping buildDefaultJavaAttributeMapping(JavaPersistentAttribute attribute);
-
+	
 	/**
-	 * Return the Java attribute mapping key for the default mapping for the
-	 * specified attribute.
-	 * @see org.eclipse.jpt.core.context.java.DefaultJavaAttributeMappingProvider#defaultApplies(JavaPersistentAttribute)
+	 * Return a {@link JavaAttributeMappingProvider} that describes the interpretation of the attribute
+	 * as it exists, ignoring all annotations.
+	 * This may not be null (@see {@link NullDefaultJavaAttributeMappingProvider},) else
+	 * an {@link IllegalStateException} is thrown.
+	 * 
+	 * @param attribute The persistent attribute to analyze
+	 * @return The mapping provider describing the unannotated state of the attribute
 	 */
-	String getDefaultJavaAttributeMappingKey(JavaPersistentAttribute attribute);
-
-
-	// ********** Mapping File **********
-
-	MappingFile buildMappingFile(MappingFileRef parent, JpaXmlResource resource);
-
-
-	// ********** ORM type mappings **********
-
-	XmlTypeMapping buildOrmResourceTypeMapping(String key, IContentType contentType);
-
+	JavaAttributeMappingProvider getDefaultJavaAttributeMappingProvider(JavaPersistentAttribute attribute);
+	
 	/**
-	 * Build an ORM type mapping for the specified mapping key and persistent type.
-	 * Use identity when comparing keys; so clients must use the same key
-	 * constants as the providers.
+	 * Return a {@link JavaAttributeMappingProvider} that describes the interpretation of the attribute
+	 * as it exists, complete with annotations.  It is assumed that the attribute's default mapping
+	 * has already been determined.
+	 * This may be null.
+	 * 
+	 * @param attribute The persistent attribute to analyze
+	 * @return The mapping provider describing the annotated state of the attribute
 	 */
-	OrmTypeMapping buildOrmTypeMappingFromMappingKey(OrmPersistentType type, XmlTypeMapping resourceMapping);
-
-
-	// ********** ORM attribute mappings **********
-
-	XmlAttributeMapping buildOrmResourceAttributeMapping(String key, IContentType contentType);
-
+	JavaAttributeMappingProvider getSpecifiedJavaAttributeMappingProvider(JavaPersistentAttribute attribute);
+	
 	/**
-	 * Build an ORM attribute mapping for the specified key and persistent attribute.
-	 * Use identity when comparing keys; so clients must use the same key
-	 * constants as the providers.
+	 * Return a {@link JavaAttributeMappingProvider} for the given mapping key.
+	 * Throw an {@link IllegalArgumentException} if the key is not supported by the platform.
 	 */
-	OrmAttributeMapping buildOrmAttributeMappingFromMappingKey(OrmPersistentAttribute parent, XmlAttributeMapping resourceMapping);
-
+	JavaAttributeMappingProvider getSpecifiedJavaAttributeMappingProvider(String mappingKey);
+	
+	
+	// ********** Mapping Files **********
+	
 	/**
-	 * Build a virtual resource attribute mapping to be used when the mapping is not specified in the orm.xml
-	 * file.  There is no XmlAttributeMapping in this case, so we build one that delegates to the 
-	 * JavaAttributeMapping as necessary
+	 * Return a {@link MappingFileDefinition} to describe the context model for a file of the given
+	 * content type.
+	 * Thrown an {@link IllegalArgumentException} if the content type is not supported by the platform.
+	 * 
+	 * @param contentType The content type of a potential mapping file
+	 * @return The mapping file definition that can be used to describe the context model of such
+	 * a file
 	 */
-	XmlAttributeMapping buildVirtualOrmResourceMappingFromMappingKey(String key, OrmTypeMapping ormTypeMapping, JavaAttributeMapping javaAttributeMapping);
-
-
+	MappingFileDefinition getMappingFileDefinition(IContentType contentType);
+	
+	
 	// ********** database **********
 
 	/**
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/JpaPlatformProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/JpaPlatformProvider.java
index 63944f68dd..7e779dcff7 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/JpaPlatformProvider.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/JpaPlatformProvider.java
@@ -10,12 +10,9 @@
 package org.eclipse.jpt.core;
 
 import java.util.ListIterator;
-import org.eclipse.jpt.core.context.MappingFileProvider;
-import org.eclipse.jpt.core.context.java.DefaultJavaAttributeMappingProvider;
+import org.eclipse.jpt.core.context.MappingFileDefinition;
 import org.eclipse.jpt.core.context.java.JavaAttributeMappingProvider;
 import org.eclipse.jpt.core.context.java.JavaTypeMappingProvider;
-import org.eclipse.jpt.core.context.orm.OrmAttributeMappingProvider;
-import org.eclipse.jpt.core.context.orm.OrmTypeMappingProvider;
 
 /**
  * This interface is to be implemented by a JPA vendor to provide extensions to 
@@ -44,33 +41,22 @@ public interface JpaPlatformProvider
 	ListIterator<JpaResourceModelProvider> resourceModelProviders();
 
 	/**
-	 * Return the java type mapping providers that apply to this platform.
-	 */
-	ListIterator<JavaTypeMappingProvider> javaTypeMappingProviders();
-
-	/**
-	 * Return the java attribute mapping providers that apply to this platform.
-	 */
-	ListIterator<JavaAttributeMappingProvider> javaAttributeMappingProviders();
-
-	/**
-	 * Return the mapping file providers that apply to this platform.
+	 * Return the mapping file definitions supported by this platform.
 	 */
-	ListIterator<MappingFileProvider> mappingFileProviders();
+	ListIterator<MappingFileDefinition> mappingFileDefinitions();
 
 	/**
-	 * Return the default java attribute mapping providers that apply to this platform.
+	 * Return the java type mapping providers that apply to this platform.
 	 */
-	ListIterator<DefaultJavaAttributeMappingProvider> defaultJavaAttributeMappingProviders();
-
+	ListIterator<JavaTypeMappingProvider> javaTypeMappingProviders();
+	
 	/**
-	 * Return the orm type mapping providers that apply to this platform.
+	 * Return the mapping providers to use for default java attribute mappings for this platform.
 	 */
-	ListIterator<OrmTypeMappingProvider> ormTypeMappingProviders();
+	ListIterator<JavaAttributeMappingProvider> defaultJavaAttributeMappingProviders();
 
 	/**
-	 * Return the orm attribute mapping providers that apply to this platform.
+	 * Return the mapping providers to use for specified java attribute mappings for this platform.
 	 */
-	ListIterator<OrmAttributeMappingProvider> ormAttributeMappingProviders();
-
+	ListIterator<JavaAttributeMappingProvider> specifiedJavaAttributeMappingProviders();
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/MappingFileProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/MappingFileDefinition.java
index 1528ec9aaa..266bffad5e 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/MappingFileProvider.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/MappingFileDefinition.java
@@ -11,6 +11,9 @@ package org.eclipse.jpt.core.context;
 
 import org.eclipse.core.runtime.content.IContentType;
 import org.eclipse.jpt.core.JpaFactory;
+import org.eclipse.jpt.core.context.orm.OrmAttributeMappingProvider;
+import org.eclipse.jpt.core.context.orm.NullOrmAttributeMappingProvider;
+import org.eclipse.jpt.core.context.orm.OrmTypeMappingProvider;
 import org.eclipse.jpt.core.context.persistence.MappingFileRef;
 import org.eclipse.jpt.core.resource.xml.JpaXmlResource;
 
@@ -21,8 +24,8 @@ import org.eclipse.jpt.core.resource.xml.JpaXmlResource;
  * pioneering adopters on the understanding that any code that uses this API
  * will almost certainly be broken (repeatedly) as the API evolves.
  */
-public interface MappingFileProvider {
-
+public interface MappingFileDefinition 
+{
 	/**
 	 * Return the associated mapping file content type.
 	 */
@@ -32,5 +35,26 @@ public interface MappingFileProvider {
 	 * Build a mapping with the specified parent and resource.
 	 */
 	MappingFile buildMappingFile(MappingFileRef parent, JpaXmlResource resource, JpaFactory factory);
-
+	
+	
+	// ********** ORM type/attribute mappings **********
+	
+	/**
+	 * Return an {@link OrmTypeMappingProvider} for the given type mapping key.
+	 * Throws an {@link IllegalArgumentException} if the mapping key is not supported.
+	 * 
+	 * @param mappingKey The type mapping key
+	 * @return The mapping provider for the given mapping key
+	 */
+	OrmTypeMappingProvider getOrmTypeMappingProvider(String mappingKey);
+	
+	/**
+	 * Return an {@link OrmAttributeMappingProvider} for the given attribute mapping key.
+	 * This must not return null.  (@see {@link NullOrmAttributeMappingProvider})
+	 * Throws an {@link IllegalArgumentException} if the mapping key is not supported.
+	 * 
+	 * @param mappingKey The attribute mapping key
+	 * @return The mapping provider for the given mapping key
+	 */
+	OrmAttributeMappingProvider getOrmAttributeMappingProvider(String mappingKey);
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/DefaultJavaAttributeMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/DefaultJavaAttributeMappingProvider.java
deleted file mode 100644
index 43f3700ba4..0000000000
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/DefaultJavaAttributeMappingProvider.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006, 2008 Oracle. All rights reserved.
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0, which accompanies this distribution
- * and is available at http://www.eclipse.org/legal/epl-v10.html.
- * 
- * Contributors:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.core.context.java;
-
-
-/**
- * Map a string key to an attribute mapping and its corresponding
- * Java annotation adapter.  
- * 
- * 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.
- */
-public interface DefaultJavaAttributeMappingProvider extends JavaAttributeMappingProvider {
-
-	/**
-	 * Given the IJavaPersistentAttribute return whether the default mapping applies.
-	 * This will be used to determine the default mapping in the case where no 
-	 * mapping has been specified.
-	 */
-	boolean defaultApplies(JavaPersistentAttribute persistentAttribute);
-
-}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaAttributeMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaAttributeMappingProvider.java
index 76a04ed3a9..1c10bfdf78 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaAttributeMappingProvider.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaAttributeMappingProvider.java
@@ -21,23 +21,34 @@ import org.eclipse.jpt.core.JpaFactory;
  * pioneering adopters on the understanding that any code that uses this API
  * will almost certainly be broken (repeatedly) as the API evolves.
  */
-public interface JavaAttributeMappingProvider {
-
+public interface JavaAttributeMappingProvider 
+{
 	/**
 	 * Return the attribute mapping's key.
 	 */
 	String getKey();
-
+	
 	/**
 	 * Return the attribute mapping's Java annotation name.
 	 */
 	String getAnnotationName();
-
+	
 	/**
 	 * Build a Java attribute mapping for the specified attribute. Use the specified
 	 * factory for creation so extenders can simply override the appropriate
 	 * creation method instead of building a provider for the same key.
 	 */
 	JavaAttributeMapping buildMapping(JavaPersistentAttribute attribute, JpaFactory factory);
-
+	
+	/**
+	 * Return whether this mapping provider should be used for the given {@link JavaPersistentAttribute} 
+	 * in the default (ignoring all mapping annotations) case.
+	 */
+	boolean defaultApplies(JavaPersistentAttribute persistentAttribute);
+	
+	/**
+	 * Return whether this mapping provider should be used for the given {@link JavaPersistentAttribute} 
+	 * in the specified (observing all mapping annotations) case.
+	 */
+	boolean specifiedApplies(JavaPersistentAttribute persistentAttribute);
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/NullDefaultJavaAttributeMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/NullDefaultJavaAttributeMappingProvider.java
new file mode 100644
index 0000000000..fe1e627bda
--- /dev/null
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/NullDefaultJavaAttributeMappingProvider.java
@@ -0,0 +1,71 @@
+/*******************************************************************************
+ * Copyright (c) 2009 Oracle. All rights reserved.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0, which accompanies this distribution
+ * and is available at http://www.eclipse.org/legal/epl-v10.html.
+ * 
+ * Contributors:
+ *     Oracle - initial API and implementation
+ ******************************************************************************/
+package org.eclipse.jpt.core.context.java;
+
+import org.eclipse.jpt.core.JpaFactory;
+import org.eclipse.jpt.core.MappingKeys;
+
+/**
+ * This mapping provider implementation is used to describe the default mapping for 
+ * a java attribute when no other mapping applies.
+ */
+public class NullDefaultJavaAttributeMappingProvider
+	implements JavaAttributeMappingProvider
+{
+	// singleton
+	private static final NullDefaultJavaAttributeMappingProvider INSTANCE = 
+		new NullDefaultJavaAttributeMappingProvider();
+	
+	
+	/**
+	 * Return the singleton.
+	 */
+	public static JavaAttributeMappingProvider instance() {
+		return INSTANCE;
+	}
+	
+	
+	/**
+	 * Enforce singleton usage
+	 */
+	private NullDefaultJavaAttributeMappingProvider() {
+		super();
+	}
+	
+	
+	public String getKey() {
+		return MappingKeys.NULL_ATTRIBUTE_MAPPING_KEY;
+	}
+	
+	public String getAnnotationName() {
+		return null;
+	}
+	
+	/**
+	 * Default mappings should never be null
+	 */
+	public JavaAttributeMapping buildMapping(JavaPersistentAttribute parent, JpaFactory factory) {
+		return factory.buildJavaNullAttributeMapping(parent);
+	}
+	
+	/**
+	 * This is typically the final test, so it should always apply
+	 */
+	public boolean defaultApplies(JavaPersistentAttribute persistentAttribute) {
+		return true;
+	}
+	
+	/**
+	 * Obviously, always false
+	 */
+	public boolean specifiedApplies(JavaPersistentAttribute persistentAttribute) {
+		return false;
+	}
+}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaNullTypeMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/NullJavaTypeMappingProvider.java
index 94cfde7742..aec6fb2cc7 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaNullTypeMappingProvider.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/NullJavaTypeMappingProvider.java
@@ -7,12 +7,9 @@
  * Contributors:
  *     Oracle - initial API and implementation
  ******************************************************************************/
-package org.eclipse.jpt.core.internal.context.java;
+package org.eclipse.jpt.core.context.java;
 
 import org.eclipse.jpt.core.JpaFactory;
-import org.eclipse.jpt.core.context.java.JavaPersistentType;
-import org.eclipse.jpt.core.context.java.JavaTypeMapping;
-import org.eclipse.jpt.core.context.java.JavaTypeMappingProvider;
 import org.eclipse.jpt.utility.internal.StringTools;
 
 /**
@@ -20,31 +17,33 @@ import org.eclipse.jpt.utility.internal.StringTools;
  * A JavaNullAttributeMapping should be used when no "mapping" annotation
  * exists on a Java type. 
  */
-public class JavaNullTypeMappingProvider
+public class NullJavaTypeMappingProvider
 	implements JavaTypeMappingProvider
 {
-
 	// singleton
-	private static final JavaNullTypeMappingProvider INSTANCE = new JavaNullTypeMappingProvider();
-
+	private static final NullJavaTypeMappingProvider INSTANCE = new NullJavaTypeMappingProvider();
+	
+	
 	/**
 	 * Return the singleton.
 	 */
 	public static JavaTypeMappingProvider instance() {
 		return INSTANCE;
 	}
-
+	
+	
 	/**
-	 * Ensure single instance.
+	 * Enforce singleton usage
 	 */
-	private JavaNullTypeMappingProvider() {
+	private NullJavaTypeMappingProvider() {
 		super();
 	}
-
+	
+	
 	public String getKey() {
 		return null;
 	}
-
+	
 	public String getAnnotationName() {
 		return null;
 	}
@@ -52,10 +51,9 @@ public class JavaNullTypeMappingProvider
 	public JavaTypeMapping buildMapping(JavaPersistentType parent, JpaFactory factory) {
 		return factory.buildJavaNullTypeMapping(parent);
 	}
-
+	
 	@Override
 	public String toString() {
 		return StringTools.buildToStringFor(this, this.getAnnotationName());
 	}
-
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/NullSpecifiedJavaAttributeMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/NullSpecifiedJavaAttributeMappingProvider.java
new file mode 100644
index 0000000000..a36b941c17
--- /dev/null
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/NullSpecifiedJavaAttributeMappingProvider.java
@@ -0,0 +1,71 @@
+/*******************************************************************************
+ * Copyright (c) 2009 Oracle. All rights reserved.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0, which accompanies this distribution
+ * and is available at http://www.eclipse.org/legal/epl-v10.html.
+ * 
+ * Contributors:
+ *     Oracle - initial API and implementation
+ ******************************************************************************/
+package org.eclipse.jpt.core.context.java;
+
+import org.eclipse.jpt.core.JpaFactory;
+import org.eclipse.jpt.core.MappingKeys;
+
+/**
+ * This mapping provider implementation is used to describe the specified mapping for 
+ * a java attribute when no other mapping applies.
+ */
+public class NullSpecifiedJavaAttributeMappingProvider
+	implements JavaAttributeMappingProvider
+{
+	// singleton
+	private static final NullSpecifiedJavaAttributeMappingProvider INSTANCE = 
+		new NullSpecifiedJavaAttributeMappingProvider();
+	
+	
+	/**
+	 * Return the singleton.
+	 */
+	public static JavaAttributeMappingProvider instance() {
+		return INSTANCE;
+	}
+	
+	
+	/**
+	 * Enforce singleton usage
+	 */
+	private NullSpecifiedJavaAttributeMappingProvider() {
+		super();
+	}
+	
+	
+	public String getKey() {
+		return MappingKeys.NULL_ATTRIBUTE_MAPPING_KEY;
+	}
+	
+	public String getAnnotationName() {
+		return null;
+	}
+	
+	/**
+	 * There is no specified mapping in this case, attributes should revert to the default
+	 */
+	public JavaAttributeMapping buildMapping(JavaPersistentAttribute parent, JpaFactory factory) {
+		return null;
+	}
+	
+	/**
+	 * Obviously false
+	 */
+	public boolean defaultApplies(JavaPersistentAttribute persistentAttribute) {
+		return false;
+	}
+	
+	/**
+	 * This is typically the final test, so it should always apply
+	 */
+	public boolean specifiedApplies(JavaPersistentAttribute persistentAttribute) {
+		return true;
+	}
+}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/NullOrmAttributeMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/NullOrmAttributeMappingProvider.java
new file mode 100644
index 0000000000..22fc56fd0e
--- /dev/null
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/NullOrmAttributeMappingProvider.java
@@ -0,0 +1,63 @@
+/*******************************************************************************
+ * Copyright (c) 2007, 2009 Oracle. All rights reserved.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0, which accompanies this distribution
+ * and is available at http://www.eclipse.org/legal/epl-v10.html.
+ * 
+ * Contributors:
+ *     Oracle - initial API and implementation
+ ******************************************************************************/
+package org.eclipse.jpt.core.context.orm;
+
+import org.eclipse.core.runtime.content.IContentType;
+import org.eclipse.jpt.core.JpaFactory;
+import org.eclipse.jpt.core.JptCorePlugin;
+import org.eclipse.jpt.core.MappingKeys;
+import org.eclipse.jpt.core.context.java.JavaAttributeMapping;
+import org.eclipse.jpt.core.resource.orm.XmlAttributeMapping;
+import org.eclipse.jpt.core.resource.orm.XmlNullAttributeMapping;
+
+public class NullOrmAttributeMappingProvider
+	implements OrmAttributeMappingProvider
+{
+	// singleton
+	private static final OrmAttributeMappingProvider INSTANCE = 
+			new NullOrmAttributeMappingProvider();
+	
+	
+	/**
+	 * Return the singleton.
+	 */
+	public static OrmAttributeMappingProvider instance() {
+		return INSTANCE;
+	}
+	
+	
+	/**
+	 * Enforce singleton usage
+	 */
+	private NullOrmAttributeMappingProvider() {
+		super();
+	}
+	
+	
+	public IContentType getContentType() {
+		return JptCorePlugin.ORM_XML_CONTENT_TYPE;
+	}
+
+	public String getKey() {
+		return MappingKeys.NULL_ATTRIBUTE_MAPPING_KEY;
+	}
+	
+	public XmlAttributeMapping buildResourceMapping() {
+		throw new UnsupportedOperationException();
+	}
+
+	public OrmAttributeMapping buildMapping(OrmPersistentAttribute parent, XmlAttributeMapping resourceMapping, JpaFactory factory) {
+		return factory.buildOrmNullAttributeMapping(parent, (XmlNullAttributeMapping) resourceMapping);
+	}
+	
+	public XmlAttributeMapping buildVirtualResourceMapping(OrmTypeMapping ormTypeMapping, JavaAttributeMapping javaAttributeMapping, JpaFactory factory) {
+		return factory.buildVirtualXmlNullAttributeMapping(ormTypeMapping, javaAttributeMapping);
+	}
+}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/GenericMappingFileProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/GenericMappingFileProvider.java
deleted file mode 100644
index e50ac92b92..0000000000
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/GenericMappingFileProvider.java
+++ /dev/null
@@ -1,48 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008, 2009 Oracle. All rights reserved.
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0, which accompanies this distribution
- * and is available at http://www.eclipse.org/legal/epl-v10.html.
- * 
- * Contributors:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.core.internal.context;
-
-import org.eclipse.core.runtime.content.IContentType;
-import org.eclipse.jpt.core.JpaFactory;
-import org.eclipse.jpt.core.JptCorePlugin;
-import org.eclipse.jpt.core.context.MappingFile;
-import org.eclipse.jpt.core.context.MappingFileProvider;
-import org.eclipse.jpt.core.context.persistence.MappingFileRef;
-import org.eclipse.jpt.core.resource.xml.JpaXmlResource;
-
-public class GenericMappingFileProvider
-	implements MappingFileProvider
-{
-	// singleton
-	private static final MappingFileProvider INSTANCE = new GenericMappingFileProvider();
-
-	/**
-	 * Return the singleton.
-	 */
-	public static MappingFileProvider instance() {
-		return INSTANCE;
-	}
-
-	/**
-	 * Ensure single instance.
-	 */
-	private GenericMappingFileProvider() {
-		super();
-	}
-
-	public IContentType getContentType() {
-		return JptCorePlugin.ORM_XML_CONTENT_TYPE;
-	}
-
-	public MappingFile buildMappingFile(MappingFileRef parent, JpaXmlResource resource, JpaFactory factory) {
-		return factory.buildMappingFile(parent, resource);
-	}
-
-}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaAttributeMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaAttributeMappingProvider.java
new file mode 100644
index 0000000000..ceff9b1d50
--- /dev/null
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaAttributeMappingProvider.java
@@ -0,0 +1,36 @@
+/*******************************************************************************
+ * Copyright (c) 2009 Oracle. All rights reserved.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0, which accompanies this distribution
+ * and is available at http://www.eclipse.org/legal/epl-v10.html.
+ * 
+ * Contributors:
+ *     Oracle - initial API and implementation
+ ******************************************************************************/
+package org.eclipse.jpt.core.internal.context.java;
+
+import org.eclipse.jpt.core.context.java.JavaAttributeMappingProvider;
+import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;
+
+public abstract class AbstractJavaAttributeMappingProvider
+	implements JavaAttributeMappingProvider
+{
+	protected AbstractJavaAttributeMappingProvider() {
+		super();
+	}
+	
+	/**
+	 * Default implementation.  Override if the mapping provider ever applies in the default case.
+	 */
+	public boolean defaultApplies(JavaPersistentAttribute persistentAttribute) {
+		return false;
+	}
+	
+	/**
+	 * Default implementation.  Override if the mapping provider needs to do more analysis.
+	 */
+	public boolean specifiedApplies(JavaPersistentAttribute persistentAttribute) {
+		return persistentAttribute.getResourcePersistentAttribute().getMappingAnnotation(getAnnotationName()) 
+			!= null;
+	}
+}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaPersistentAttribute.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaPersistentAttribute.java
index c3cb67a6eb..fbba2e0b23 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaPersistentAttribute.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaPersistentAttribute.java
@@ -11,7 +11,6 @@ package org.eclipse.jpt.core.internal.context.java;
 
 import java.util.Iterator;
 import java.util.List;
-
 import org.eclipse.core.runtime.content.IContentType;
 import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jdt.core.dom.Modifier;
@@ -22,6 +21,7 @@ import org.eclipse.jpt.core.context.Embeddable;
 import org.eclipse.jpt.core.context.PersistentType;
 import org.eclipse.jpt.core.context.TypeMapping;
 import org.eclipse.jpt.core.context.java.JavaAttributeMapping;
+import org.eclipse.jpt.core.context.java.JavaAttributeMappingProvider;
 import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;
 import org.eclipse.jpt.core.context.java.JavaStructureNodes;
 import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages;
@@ -56,9 +56,9 @@ public abstract class AbstractJavaPersistentAttribute
 	protected AbstractJavaPersistentAttribute(PersistentType parent, JavaResourcePersistentAttribute resourcePersistentAttribute) {
 		super(parent);
 		this.resourcePersistentAttribute = resourcePersistentAttribute;
-		this.name = this.buildName();
-		this.defaultMapping = this.buildDefaultMapping();
-		this.specifiedMapping = this.buildJavaAttributeMappingFromAnnotation(this.getJavaMappingAnnotationName());
+		this.name = buildName();
+		this.defaultMapping = buildDefaultMapping();
+		this.specifiedMapping = buildSpecifiedMapping();
 	}
 
 
@@ -374,6 +374,7 @@ public abstract class AbstractJavaPersistentAttribute
 		return this.getMapping().getKey();
 	}
 
+
 	// ***** default mapping
 	public JavaAttributeMapping getDefaultMapping() {
 		return this.defaultMapping;
@@ -389,12 +390,19 @@ public abstract class AbstractJavaPersistentAttribute
 	}
 
 	protected JavaAttributeMapping buildDefaultMapping() {
-		JavaAttributeMapping mapping = this.getJpaPlatform().buildDefaultJavaAttributeMapping(this);
-		Annotation annotation = this.resourcePersistentAttribute.getNullMappingAnnotation(mapping.getAnnotationName());
+		JavaAttributeMappingProvider mappingProvider = 
+			getJpaPlatform().getDefaultJavaAttributeMappingProvider(this);
+		return buildDefaultMapping(mappingProvider);
+	}
+	
+	protected JavaAttributeMapping buildDefaultMapping(JavaAttributeMappingProvider mappingProvider) {
+		Annotation annotation = 
+			this.resourcePersistentAttribute.getNullMappingAnnotation(mappingProvider.getAnnotationName());
+		JavaAttributeMapping mapping = mappingProvider.buildMapping(this, getJpaFactory());
 		mapping.initialize(annotation);
 		return mapping;
 	}
-
+	
 	/**
 	 * return null if there is no "default" mapping for the attribute
 	 */
@@ -424,8 +432,29 @@ public abstract class AbstractJavaPersistentAttribute
 		this.firePropertyChanged(SPECIFIED_MAPPING_PROPERTY, old, specifiedMapping);
 	}
 
+	protected JavaAttributeMapping buildSpecifiedMapping() {
+		JavaAttributeMappingProvider mappingProvider = 
+			getJpaPlatform().getSpecifiedJavaAttributeMappingProvider(this);
+		return buildSpecifiedMapping(mappingProvider);
+	}
+	
+	protected JavaAttributeMapping buildSpecifiedMapping(JavaAttributeMappingProvider mappingProvider) {
+		if (mappingProvider == null) {
+			return null;
+		}
+		Annotation annotation =
+			this.resourcePersistentAttribute.getMappingAnnotation(mappingProvider.getAnnotationName());
+		JavaAttributeMapping mapping = mappingProvider.buildMapping(this, getJpaFactory());
+		// specified mappings may be null
+		if (mapping != null) {
+			mapping.initialize(annotation);
+		}
+		return mapping;
+	}
+	
 	/**
-	 * return null if there is no "specified" mapping for the attribute
+	 * return the key of the currently specified mapping or null 
+	 * if there is no specified mapping for the attribute
 	 */
 	protected String getSpecifiedMappingKey() {
 		return (this.specifiedMapping == null) ? null : this.specifiedMapping.getKey();
@@ -454,12 +483,18 @@ public abstract class AbstractJavaPersistentAttribute
 			}
 		}
 	}
-
+	
+	/**
+	 * return the annotation name of the currently specified mapping or null 
+	 * if there is no specified mapping for the attribute
+	 */
+	protected String getSpecifiedMappingAnnotationName() {
+		return (this.specifiedMapping == null) ? null : this.specifiedMapping.getAnnotationName();
+	}
+	
 	protected JavaAttributeMapping buildMappingFromMappingKey(String key) {
-		if (key == MappingKeys.NULL_ATTRIBUTE_MAPPING_KEY) {
-			return null;
-		}
-		JavaAttributeMapping mapping = this.getJpaPlatform().buildJavaAttributeMappingFromMappingKey(key, this);
+		JavaAttributeMappingProvider mappingProvider = getJpaPlatform().getSpecifiedJavaAttributeMappingProvider(key);
+		JavaAttributeMapping mapping = mappingProvider.buildMapping(this, getJpaFactory());
 		//no mapping.initialize(JavaResourcePersistentAttribute) call here
 		//we do not yet have a mapping annotation so we can't call initialize
 		return mapping;
@@ -480,46 +515,37 @@ public abstract class AbstractJavaPersistentAttribute
 	}
 
 	protected void updateDefaultMapping() {
-		String defaultMappingKey = this.getJpaPlatform().getDefaultJavaAttributeMappingKey(this);
-		if (this.defaultMapping.getKey() == defaultMappingKey) {
-			this.defaultMapping.update(this.resourcePersistentAttribute.getNullMappingAnnotation(this.defaultMapping.getAnnotationName()));
-		} else {
-			JavaAttributeMapping old = this.defaultMapping;
-			this.defaultMapping = this.buildDefaultMapping();
-			this.firePropertyChanged(DEFAULT_MAPPING_PROPERTY, old, this.defaultMapping);
+		// There will always be a mapping provider, even if it is a "null" mapping provider ...
+		JavaAttributeMappingProvider mappingProvider = 
+			getJpaPlatform().getDefaultJavaAttributeMappingProvider(this);
+		String mappingKey = mappingProvider.getKey();
+		if (this.defaultMapping.getKey() == mappingKey) {
+			this.defaultMapping.update(
+				this.resourcePersistentAttribute.getNullMappingAnnotation(
+					mappingProvider.getAnnotationName()));
+		} 
+		else {
+			setDefaultMapping(buildDefaultMapping(mappingProvider));
 		}
 	}
 
 	protected void updateSpecifiedMapping() {
-		String javaMappingAnnotationName = this.getJavaMappingAnnotationName();
-		if (javaMappingAnnotationName == this.getSpecifiedMappingAnnotationName()) {
-			if (this.specifiedMapping != null) {
-				this.specifiedMapping.update(this.resourcePersistentAttribute.getMappingAnnotation(javaMappingAnnotationName));
-			}
-		} else {
-			this.setSpecifiedMapping(this.buildJavaAttributeMappingFromAnnotation(javaMappingAnnotationName));
+		// There may not be a mapping provider ...
+		JavaAttributeMappingProvider mappingProvider = 
+			getJpaPlatform().getSpecifiedJavaAttributeMappingProvider(this);
+		// ... so there may not be a mapping annotation name
+		String annotationName = (mappingProvider == null) ? null : mappingProvider.getAnnotationName();
+		if (this.specifiedMapping != null
+				&& this.specifiedMapping.getAnnotationName().equals(annotationName)) {
+			this.specifiedMapping.update(
+				this.resourcePersistentAttribute.getMappingAnnotation(annotationName));
+		} 
+		else {
+			setSpecifiedMapping(buildSpecifiedMapping(mappingProvider));
 		}
 	}
-
-	protected String getJavaMappingAnnotationName() {
-		Annotation mappingAnnotation = this.resourcePersistentAttribute.getMappingAnnotation();
-		return (mappingAnnotation == null) ? null : mappingAnnotation.getAnnotationName();
-	}
-
-	protected String getSpecifiedMappingAnnotationName() {
-		return (this.specifiedMapping == null) ? null : this.specifiedMapping.getAnnotationName();
-	}
-
-	protected JavaAttributeMapping buildJavaAttributeMappingFromAnnotation(String annotationName) {
-		if (annotationName == null) {
-			return null;
-		}
-		JavaAttributeMapping mapping = getJpaPlatform().buildJavaAttributeMappingFromAnnotation(annotationName, this);
-		mapping.initialize(this.resourcePersistentAttribute.getMappingAnnotation(annotationName));
-		return mapping;
-	}
-
-
+	
+	
 	// ********** validation **********
 
 	public TextRange getValidationTextRange(CompilationUnit astRoot) {
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaBasicMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaBasicMappingProvider.java
index db6890c12a..ac1b162b0d 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaBasicMappingProvider.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaBasicMappingProvider.java
@@ -11,32 +11,35 @@ package org.eclipse.jpt.core.internal.context.java;
 
 import org.eclipse.jpt.core.JpaFactory;
 import org.eclipse.jpt.core.MappingKeys;
-import org.eclipse.jpt.core.context.java.DefaultJavaAttributeMappingProvider;
 import org.eclipse.jpt.core.context.java.JavaAttributeMapping;
+import org.eclipse.jpt.core.context.java.JavaAttributeMappingProvider;
 import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;
 import org.eclipse.jpt.core.resource.java.BasicAnnotation;
 
 public class JavaBasicMappingProvider
-	implements DefaultJavaAttributeMappingProvider
+	extends AbstractJavaAttributeMappingProvider
 {
-
 	// singleton
-	private static final JavaBasicMappingProvider INSTANCE = new JavaBasicMappingProvider();
-
+	private static final JavaBasicMappingProvider INSTANCE = 
+		new JavaBasicMappingProvider();
+	
+	
 	/**
 	 * Return the singleton.
 	 */
-	public static DefaultJavaAttributeMappingProvider instance() {
+	public static JavaAttributeMappingProvider instance() {
 		return INSTANCE;
 	}
-
+	
+	
 	/**
-	 * Ensure single instance.
+	 * Enforce singleton usage
 	 */
 	private JavaBasicMappingProvider() {
 		super();
 	}
-
+	
+	
 	public String getKey() {
 		return MappingKeys.BASIC_ATTRIBUTE_MAPPING_KEY;
 	}
@@ -44,13 +47,13 @@ public class JavaBasicMappingProvider
 	public String getAnnotationName() {
 		return BasicAnnotation.ANNOTATION_NAME;
 	}
-
+	
 	public JavaAttributeMapping buildMapping(JavaPersistentAttribute parent, JpaFactory factory) {
 		return factory.buildJavaBasicMapping(parent);
 	}
 	
+	@Override
 	public boolean defaultApplies(JavaPersistentAttribute persistentAttribute) {
 		return persistentAttribute.typeIsBasic();
 	}
-
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaEmbeddedIdMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaEmbeddedIdMappingProvider.java
index cd1cd96259..db1f455666 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaEmbeddedIdMappingProvider.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaEmbeddedIdMappingProvider.java
@@ -11,32 +11,35 @@ package org.eclipse.jpt.core.internal.context.java;
 
 import org.eclipse.jpt.core.JpaFactory;
 import org.eclipse.jpt.core.MappingKeys;
-import org.eclipse.jpt.core.context.java.DefaultJavaAttributeMappingProvider;
 import org.eclipse.jpt.core.context.java.JavaAttributeMapping;
+import org.eclipse.jpt.core.context.java.JavaAttributeMappingProvider;
 import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;
 import org.eclipse.jpt.core.resource.java.EmbeddedIdAnnotation;
 
 public class JavaEmbeddedIdMappingProvider
-	implements DefaultJavaAttributeMappingProvider
+	extends AbstractJavaAttributeMappingProvider
 {
-
 	// singleton
-	private static final JavaEmbeddedIdMappingProvider INSTANCE = new JavaEmbeddedIdMappingProvider();
-
+	private static final JavaEmbeddedIdMappingProvider INSTANCE = 
+		new JavaEmbeddedIdMappingProvider();
+	
+	
 	/**
 	 * Return the singleton.
 	 */
-	public static DefaultJavaAttributeMappingProvider instance() {
+	public static JavaAttributeMappingProvider instance() {
 		return INSTANCE;
 	}
-
+	
+	
 	/**
-	 * Ensure single instance.
+	 * Enforce singletong usage
 	 */
 	private JavaEmbeddedIdMappingProvider() {
 		super();
 	}
-
+	
+	
 	public String getKey() {
 		return MappingKeys.EMBEDDED_ID_ATTRIBUTE_MAPPING_KEY;
 	}
@@ -44,12 +47,8 @@ public class JavaEmbeddedIdMappingProvider
 	public String getAnnotationName() {
 		return EmbeddedIdAnnotation.ANNOTATION_NAME;
 	}
-
+	
 	public JavaAttributeMapping buildMapping(JavaPersistentAttribute parent, JpaFactory factory) {
 		return factory.buildJavaEmbeddedIdMapping(parent);
 	}
-	
-	public boolean defaultApplies(JavaPersistentAttribute persistentAttribute) {
-		return persistentAttribute.getEmbeddable() != null;
-	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaEmbeddedMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaEmbeddedMappingProvider.java
index 47335e3158..696f2687e5 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaEmbeddedMappingProvider.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaEmbeddedMappingProvider.java
@@ -11,32 +11,35 @@ package org.eclipse.jpt.core.internal.context.java;
 
 import org.eclipse.jpt.core.JpaFactory;
 import org.eclipse.jpt.core.MappingKeys;
-import org.eclipse.jpt.core.context.java.DefaultJavaAttributeMappingProvider;
 import org.eclipse.jpt.core.context.java.JavaAttributeMapping;
+import org.eclipse.jpt.core.context.java.JavaAttributeMappingProvider;
 import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;
 import org.eclipse.jpt.core.resource.java.EmbeddedAnnotation;
 
 public class JavaEmbeddedMappingProvider
-	implements DefaultJavaAttributeMappingProvider
+	extends AbstractJavaAttributeMappingProvider
 {
-
 	// singleton
-	private static final JavaEmbeddedMappingProvider INSTANCE = new JavaEmbeddedMappingProvider();
-
+	private static final JavaEmbeddedMappingProvider INSTANCE = 
+		new JavaEmbeddedMappingProvider();
+	
+	
 	/**
 	 * Return the singleton.
 	 */
-	public static DefaultJavaAttributeMappingProvider instance() {
+	public static JavaAttributeMappingProvider instance() {
 		return INSTANCE;
 	}
-
+	
+	
 	/**
-	 * Ensure single instance.
+	 * Enforce singleton usage
 	 */
 	private JavaEmbeddedMappingProvider() {
 		super();
 	}
-
+	
+	
 	public String getKey() {
 		return MappingKeys.EMBEDDED_ATTRIBUTE_MAPPING_KEY;
 	}
@@ -44,11 +47,12 @@ public class JavaEmbeddedMappingProvider
 	public String getAnnotationName() {
 		return EmbeddedAnnotation.ANNOTATION_NAME;
 	}
-
+	
 	public JavaAttributeMapping buildMapping(JavaPersistentAttribute parent, JpaFactory factory) {
 		return factory.buildJavaEmbeddedMapping(parent);
 	}
 	
+	@Override
 	public boolean defaultApplies(JavaPersistentAttribute persistentAttribute) {
 		return persistentAttribute.getEmbeddable() != null;
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaIdMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaIdMappingProvider.java
index 013f5eed1e..307a73b328 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaIdMappingProvider.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaIdMappingProvider.java
@@ -17,26 +17,29 @@ import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;
 import org.eclipse.jpt.core.resource.java.IdAnnotation;
 
 public class JavaIdMappingProvider
-	implements JavaAttributeMappingProvider
+	extends AbstractJavaAttributeMappingProvider
 {
-
 	// singleton
-	private static final JavaIdMappingProvider INSTANCE = new JavaIdMappingProvider();
-
+	private static final JavaIdMappingProvider INSTANCE = 
+		new JavaIdMappingProvider();
+	
+	
 	/**
 	 * Return the singleton.
 	 */
 	public static JavaAttributeMappingProvider instance() {
 		return INSTANCE;
 	}
-
+	
+	
 	/**
-	 * Ensure single instance.
+	 * Enforce singleton usage
 	 */
 	private JavaIdMappingProvider() {
 		super();
 	}
-
+	
+	
 	public String getKey() {
 		return MappingKeys.ID_ATTRIBUTE_MAPPING_KEY;
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaManyToManyMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaManyToManyMappingProvider.java
index 9b540d2293..a52bc7c516 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaManyToManyMappingProvider.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaManyToManyMappingProvider.java
@@ -17,26 +17,29 @@ import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;
 import org.eclipse.jpt.core.resource.java.ManyToManyAnnotation;
 
 public class JavaManyToManyMappingProvider
-	implements JavaAttributeMappingProvider
+	extends AbstractJavaAttributeMappingProvider
 {
-
 	// singleton
-	private static final JavaManyToManyMappingProvider INSTANCE = new JavaManyToManyMappingProvider();
-
+	private static final JavaManyToManyMappingProvider INSTANCE = 
+		new JavaManyToManyMappingProvider();
+	
+	
 	/**
 	 * Return the singleton.
 	 */
 	public static JavaAttributeMappingProvider instance() {
 		return INSTANCE;
 	}
-
+	
+	
 	/**
-	 * Ensure single instance.
+	 * Enforce singleton usage
 	 */
 	private JavaManyToManyMappingProvider() {
 		super();
 	}
-
+	
+	
 	public String getKey() {
 		return MappingKeys.MANY_TO_MANY_ATTRIBUTE_MAPPING_KEY;
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaManyToOneMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaManyToOneMappingProvider.java
index dd1b262211..825483e64d 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaManyToOneMappingProvider.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaManyToOneMappingProvider.java
@@ -17,26 +17,29 @@ import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;
 import org.eclipse.jpt.core.resource.java.ManyToOneAnnotation;
 
 public class JavaManyToOneMappingProvider
-	implements JavaAttributeMappingProvider
+	extends AbstractJavaAttributeMappingProvider
 {
-
 	// singleton
-	private static final JavaManyToOneMappingProvider INSTANCE = new JavaManyToOneMappingProvider();
-
+	private static final JavaManyToOneMappingProvider INSTANCE = 
+		new JavaManyToOneMappingProvider();
+	
+	
 	/**
 	 * Return the singleton.
 	 */
 	public static JavaAttributeMappingProvider instance() {
 		return INSTANCE;
 	}
-
+	
+	
 	/**
-	 * Ensure single instance.
+	 * Enforce singleton usage
 	 */
 	private JavaManyToOneMappingProvider() {
 		super();
 	}
-
+	
+	
 	public String getKey() {
 		return MappingKeys.MANY_TO_ONE_ATTRIBUTE_MAPPING_KEY;
 	}
@@ -44,7 +47,7 @@ public class JavaManyToOneMappingProvider
 	public String getAnnotationName() {
 		return ManyToOneAnnotation.ANNOTATION_NAME;
 	}
-
+	
 	public JavaAttributeMapping buildMapping(JavaPersistentAttribute parent, JpaFactory factory) {
 		return factory.buildJavaManyToOneMapping(parent);
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaNullAttributeMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaNullAttributeMappingProvider.java
deleted file mode 100644
index 290cab10d8..0000000000
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaNullAttributeMappingProvider.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2006, 2008 Oracle. All rights reserved.
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0, which accompanies this distribution
- * and is available at http://www.eclipse.org/legal/epl-v10.html.
- * 
- * Contributors:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.core.internal.context.java;
-
-import org.eclipse.jpt.core.JpaFactory;
-import org.eclipse.jpt.core.context.java.JavaAttributeMapping;
-import org.eclipse.jpt.core.context.java.JavaAttributeMappingProvider;
-import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;
-
-/**
- * This mapping provider implementation is used to create a JavaNullAttributeMapping.
- * A JavaNullAttributeMapping should be used when no "mapping" annotation
- * exists on a Java attribute *and* no default mapping applies.
- */
-public class JavaNullAttributeMappingProvider
-	implements JavaAttributeMappingProvider
-{
-
-	// singleton
-	private static final JavaNullAttributeMappingProvider INSTANCE = new JavaNullAttributeMappingProvider();
-
-	/**
-	 * Return the singleton.
-	 */
-	public static JavaAttributeMappingProvider instance() {
-		return INSTANCE;
-	}
-
-	/**
-	 * Ensure single instance.
-	 */
-	private JavaNullAttributeMappingProvider() {
-		super();
-	}
-
-	public String getKey() {
-		return null;
-	}
-
-	public String getAnnotationName() {
-		return null;
-	}
-	
-	public JavaAttributeMapping buildMapping(JavaPersistentAttribute parent, JpaFactory factory) {
-		return factory.buildJavaNullAttributeMapping(parent);
-	}
-}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaOneToManyMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaOneToManyMappingProvider.java
index 0fa0f8e7ca..4c6c9cd747 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaOneToManyMappingProvider.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaOneToManyMappingProvider.java
@@ -17,26 +17,29 @@ import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;
 import org.eclipse.jpt.core.resource.java.OneToManyAnnotation;
 
 public class JavaOneToManyMappingProvider
-	implements JavaAttributeMappingProvider
+	extends AbstractJavaAttributeMappingProvider
 {
-
 	// singleton
-	private static final JavaOneToManyMappingProvider INSTANCE = new JavaOneToManyMappingProvider();
-
+	private static final JavaOneToManyMappingProvider INSTANCE = 
+		new JavaOneToManyMappingProvider();
+	
+	
 	/**
 	 * Return the singleton.
 	 */
 	public static JavaAttributeMappingProvider instance() {
 		return INSTANCE;
 	}
-
+	
+	
 	/**
-	 * Ensure single instance.
+	 * Enforce singletong usage
 	 */
 	private JavaOneToManyMappingProvider() {
 		super();
 	}
-
+	
+	
 	public String getKey() {
 		return MappingKeys.ONE_TO_MANY_ATTRIBUTE_MAPPING_KEY;
 	}
@@ -44,7 +47,7 @@ public class JavaOneToManyMappingProvider
 	public String getAnnotationName() {
 		return OneToManyAnnotation.ANNOTATION_NAME;
 	}
-
+	
 	public JavaAttributeMapping buildMapping(JavaPersistentAttribute parent, JpaFactory factory) {
 		return factory.buildJavaOneToManyMapping(parent);
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaOneToOneMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaOneToOneMappingProvider.java
index ed3215ef46..823285c5a7 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaOneToOneMappingProvider.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaOneToOneMappingProvider.java
@@ -17,26 +17,29 @@ import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;
 import org.eclipse.jpt.core.resource.java.OneToOneAnnotation;
 
 public class JavaOneToOneMappingProvider
-	implements JavaAttributeMappingProvider
+	extends AbstractJavaAttributeMappingProvider
 {
-
 	// singleton
-	private static final JavaOneToOneMappingProvider INSTANCE = new JavaOneToOneMappingProvider();
-
+	private static final JavaOneToOneMappingProvider INSTANCE = 
+		new JavaOneToOneMappingProvider();
+	
+	
 	/**
 	 * Return the singleton.
 	 */
 	public static JavaAttributeMappingProvider instance() {
 		return INSTANCE;
 	}
-
+	
+	
 	/**
-	 * Ensure single instance.
+	 * Enforce singleton usage
 	 */
 	private JavaOneToOneMappingProvider() {
 		super();
 	}
-
+	
+	
 	public String getKey() {
 		return MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY;
 	}
@@ -44,7 +47,7 @@ public class JavaOneToOneMappingProvider
 	public String getAnnotationName() {
 		return OneToOneAnnotation.ANNOTATION_NAME;
 	}
-
+	
 	public JavaAttributeMapping buildMapping(JavaPersistentAttribute parent, JpaFactory factory) {
 		return factory.buildJavaOneToOneMapping(parent);
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaTransientMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaTransientMappingProvider.java
index ebb98f5c7a..b5fcaf3bbd 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaTransientMappingProvider.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaTransientMappingProvider.java
@@ -17,26 +17,29 @@ import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;
 import org.eclipse.jpt.core.resource.java.TransientAnnotation;
 
 public class JavaTransientMappingProvider
-	implements JavaAttributeMappingProvider
+	extends AbstractJavaAttributeMappingProvider
 {
-
 	// singleton
-	private static final JavaTransientMappingProvider INSTANCE = new JavaTransientMappingProvider();
-
+	private static final JavaTransientMappingProvider INSTANCE = 
+		new JavaTransientMappingProvider();
+	
+	
 	/**
 	 * Return the singleton.
 	 */
 	public static JavaAttributeMappingProvider instance() {
 		return INSTANCE;
 	}
-
+	
+	
 	/**
-	 * Ensure single instance.
+	 * Enforce singleton usage
 	 */
 	private JavaTransientMappingProvider() {
 		super();
 	}
-
+	
+	
 	public String getKey() {
 		return MappingKeys.TRANSIENT_ATTRIBUTE_MAPPING_KEY;
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaVersionMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaVersionMappingProvider.java
index 78442c9274..412dbc9def 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaVersionMappingProvider.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaVersionMappingProvider.java
@@ -17,26 +17,29 @@ import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;
 import org.eclipse.jpt.core.resource.java.VersionAnnotation;
 
 public class JavaVersionMappingProvider
-	implements JavaAttributeMappingProvider
+	extends AbstractJavaAttributeMappingProvider
 {
-
 	// singleton
-	private static final JavaVersionMappingProvider INSTANCE = new JavaVersionMappingProvider();
-
+	private static final JavaVersionMappingProvider INSTANCE = 
+		new JavaVersionMappingProvider();
+	
+	
 	/**
 	 * Return the singleton.
 	 */
 	public static JavaAttributeMappingProvider instance() {
 		return INSTANCE;
 	}
-
+	
+	
 	/**
-	 * Ensure single instance.
+	 * Enforce singleton usage
 	 */
 	private JavaVersionMappingProvider() {
 		super();
 	}
-
+	
+	
 	public String getKey() {
 		return MappingKeys.VERSION_ATTRIBUTE_MAPPING_KEY;
 	}
@@ -44,7 +47,7 @@ public class JavaVersionMappingProvider
 	public String getAnnotationName() {
 		return VersionAnnotation.ANNOTATION_NAME;
 	}
-
+	
 	public JavaAttributeMapping buildMapping(JavaPersistentAttribute parent, JpaFactory factory) {
 		return factory.buildJavaVersionMapping(parent);
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractEntityMappings.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractEntityMappings.java
index 7a56a1d81d..5d5e38e4b6 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractEntityMappings.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractEntityMappings.java
@@ -15,12 +15,12 @@ import java.util.Comparator;
 import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;
-
 import org.eclipse.core.runtime.content.IContentType;
 import org.eclipse.jpt.core.JpaStructureNode;
 import org.eclipse.jpt.core.JptCorePlugin;
 import org.eclipse.jpt.core.context.AccessType;
 import org.eclipse.jpt.core.context.Generator;
+import org.eclipse.jpt.core.context.MappingFileDefinition;
 import org.eclipse.jpt.core.context.MappingFileRoot;
 import org.eclipse.jpt.core.context.PersistentType;
 import org.eclipse.jpt.core.context.orm.EntityMappings;
@@ -32,6 +32,7 @@ import org.eclipse.jpt.core.context.orm.OrmSequenceGenerator;
 import org.eclipse.jpt.core.context.orm.OrmStructureNodes;
 import org.eclipse.jpt.core.context.orm.OrmTableGenerator;
 import org.eclipse.jpt.core.context.orm.OrmTypeMapping;
+import org.eclipse.jpt.core.context.orm.OrmTypeMappingProvider;
 import org.eclipse.jpt.core.context.orm.OrmXml;
 import org.eclipse.jpt.core.context.orm.PersistenceUnitMetadata;
 import org.eclipse.jpt.core.internal.context.AbstractXmlContextNode;
@@ -111,6 +112,8 @@ public abstract class AbstractEntityMappings
 	}
 	
 	protected abstract PersistenceUnitMetadata buildPersistenceUnitMetadata();
+	
+	
 	// **************** JpaNode impl *******************************************
 	
 	@Override
@@ -348,7 +351,9 @@ public abstract class AbstractEntityMappings
 	}
 	
 	public OrmPersistentType addPersistentType(String mappingKey, String className) {
-		XmlTypeMapping typeMapping = getJpaPlatform().buildOrmResourceTypeMapping(mappingKey, getContentType());
+		OrmTypeMappingProvider mappingProvider = 
+				getMappingFileDefinition().getOrmTypeMappingProvider(mappingKey);
+		XmlTypeMapping typeMapping = mappingProvider.buildResourceMapping();
 		OrmPersistentType persistentType = buildPersistentType(typeMapping);
 		int index = insertionIndex(persistentType);
 		this.persistentTypes.add(index, persistentType);
@@ -533,6 +538,10 @@ public abstract class AbstractEntityMappings
 		return this.getOrmXml().getContentType();
 	}
 	
+	public MappingFileDefinition getMappingFileDefinition() {
+		return getJpaPlatform().getMappingFileDefinition(getContentType());
+	}
+	
 
 	// ********** initialization **********
 	
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmPersistentAttribute.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmPersistentAttribute.java
index 1896d37d40..07f790af55 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmPersistentAttribute.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmPersistentAttribute.java
@@ -14,8 +14,10 @@ import org.eclipse.core.runtime.content.IContentType;
 import org.eclipse.jpt.core.JpaStructureNode;
 import org.eclipse.jpt.core.MappingKeys;
 import org.eclipse.jpt.core.context.AccessType;
+import org.eclipse.jpt.core.context.MappingFileDefinition;
 import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;
 import org.eclipse.jpt.core.context.orm.OrmAttributeMapping;
+import org.eclipse.jpt.core.context.orm.OrmAttributeMappingProvider;
 import org.eclipse.jpt.core.context.orm.OrmPersistentAttribute;
 import org.eclipse.jpt.core.context.orm.OrmPersistentType;
 import org.eclipse.jpt.core.context.orm.OrmStructureNodes;
@@ -60,7 +62,9 @@ public abstract class AbstractOrmPersistentAttribute extends AbstractXmlContextN
 	}
 
 	protected OrmAttributeMapping buildAttributeMapping(XmlAttributeMapping resourceMapping) {
-		return getJpaPlatform().buildOrmAttributeMappingFromMappingKey(this, resourceMapping);
+		OrmAttributeMappingProvider mappingProvider = 
+				getMappingFileDefinition().getOrmAttributeMappingProvider(resourceMapping.getMappingKey());
+		return mappingProvider.buildMapping(this, resourceMapping, getJpaFactory());
 	}
 	
 	public String getId() {
@@ -104,7 +108,9 @@ public abstract class AbstractOrmPersistentAttribute extends AbstractXmlContextN
 			return;
 		}
 		OrmAttributeMapping oldMapping = this.attributeMapping;
-		XmlAttributeMapping resourceAttributeMapping = getJpaPlatform().buildOrmResourceAttributeMapping(newMappingKey, getContentType());
+		OrmAttributeMappingProvider mappingProvider = 
+				getMappingFileDefinition().getOrmAttributeMappingProvider(newMappingKey);
+		XmlAttributeMapping resourceAttributeMapping = mappingProvider.buildResourceMapping();
 		this.attributeMapping = buildAttributeMapping(resourceAttributeMapping);
 		
 		getPersistentType().changeMapping(this, oldMapping, this.attributeMapping);
@@ -180,6 +186,10 @@ public abstract class AbstractOrmPersistentAttribute extends AbstractXmlContextN
 	public IContentType getContentType() {
 		return this.getPersistentType().getContentType();
 	}
+	
+	public MappingFileDefinition getMappingFileDefinition() {
+		return getJpaPlatform().getMappingFileDefinition(getContentType());
+	}
 
 	public boolean contains(int textOffset) {
 		if (isVirtual()) {
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmPersistentType.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmPersistentType.java
index 12e07cc191..0d924690df 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmPersistentType.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmPersistentType.java
@@ -15,12 +15,12 @@ import java.util.Comparator;
 import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;
-
 import org.eclipse.core.runtime.content.IContentType;
 import org.eclipse.jpt.core.JpaStructureNode;
 import org.eclipse.jpt.core.JptCorePlugin;
 import org.eclipse.jpt.core.MappingKeys;
 import org.eclipse.jpt.core.context.AccessType;
+import org.eclipse.jpt.core.context.MappingFileDefinition;
 import org.eclipse.jpt.core.context.PersistentAttribute;
 import org.eclipse.jpt.core.context.PersistentType;
 import org.eclipse.jpt.core.context.java.JavaAttributeMapping;
@@ -28,10 +28,12 @@ import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;
 import org.eclipse.jpt.core.context.java.JavaPersistentType;
 import org.eclipse.jpt.core.context.orm.EntityMappings;
 import org.eclipse.jpt.core.context.orm.OrmAttributeMapping;
+import org.eclipse.jpt.core.context.orm.OrmAttributeMappingProvider;
 import org.eclipse.jpt.core.context.orm.OrmPersistentAttribute;
 import org.eclipse.jpt.core.context.orm.OrmPersistentType;
 import org.eclipse.jpt.core.context.orm.OrmStructureNodes;
 import org.eclipse.jpt.core.context.orm.OrmTypeMapping;
+import org.eclipse.jpt.core.context.orm.OrmTypeMappingProvider;
 import org.eclipse.jpt.core.internal.context.AbstractXmlContextNode;
 import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages;
 import org.eclipse.jpt.core.internal.validation.JpaValidationMessages;
@@ -99,7 +101,11 @@ public abstract class AbstractOrmPersistentType
 	public IContentType getContentType() {
 		return this.getEntityMappings().getContentType();
 	}
-
+	
+	public MappingFileDefinition getMappingFileDefinition() {
+		return getJpaPlatform().getMappingFileDefinition(getContentType());
+	}
+	
 	public String getDefaultPackage() {
 		return this.getEntityMappings().getDefaultPersistentTypePackage();
 	}
@@ -128,13 +134,16 @@ public abstract class AbstractOrmPersistentType
 	}
 
 	protected OrmTypeMapping buildTypeMapping(XmlTypeMapping resourceMapping) {
-		return this.getJpaPlatform().buildOrmTypeMappingFromMappingKey(this, resourceMapping);
+		OrmTypeMappingProvider mappingProvider = 
+				getMappingFileDefinition().getOrmTypeMappingProvider(resourceMapping.getMappingKey());
+		return mappingProvider.buildMapping(this, resourceMapping, getJpaFactory());
 	}
 
 	public OrmTypeMapping getMapping() {
 		return this.typeMapping;
 	}
-
+	
+	
 	// **************** PersistentType.Owner implementation *****************************
 	
 	public AccessType getOverridePersistentTypeAccess() {
@@ -180,7 +189,9 @@ public abstract class AbstractOrmPersistentType
 			return;
 		}
 		OrmTypeMapping oldMapping = getMapping();
-		XmlTypeMapping resourceTypeMapping = getJpaPlatform().buildOrmResourceTypeMapping(newMappingKey, getContentType());
+		OrmTypeMappingProvider mappingProvider = 
+				getMappingFileDefinition().getOrmTypeMappingProvider(newMappingKey);
+		XmlTypeMapping resourceTypeMapping = mappingProvider.buildResourceMapping();
 		this.typeMapping = buildTypeMapping(resourceTypeMapping);
 		this.getEntityMappings().changeMapping(this, oldMapping, this.typeMapping);
 		firePropertyChanged(MAPPING_PROPERTY, oldMapping, this.typeMapping);
@@ -296,7 +307,9 @@ public abstract class AbstractOrmPersistentType
 			getMapping().getResourceTypeMapping().setAttributes(resourceAttributes);
 		}
 		
-		XmlAttributeMapping resourceMapping = getJpaPlatform().buildOrmResourceAttributeMapping(mappingKey, getContentType());
+		OrmAttributeMappingProvider mappingProvider = 
+				getMappingFileDefinition().getOrmAttributeMappingProvider(mappingKey);
+		XmlAttributeMapping resourceMapping = mappingProvider.buildResourceMapping();
 		
 		OrmPersistentAttribute newPersistentAttribute = buildSpecifiedOrmPersistentAttribute(resourceMapping);
 		int insertionIndex = insertionIndex(newPersistentAttribute);
@@ -430,7 +443,9 @@ public abstract class AbstractOrmPersistentType
 			getMapping().getResourceTypeMapping().setAttributes(resourceAttributes);
 		}
 		
-		XmlAttributeMapping resourceMapping = getJpaPlatform().buildOrmResourceAttributeMapping(mappingKey, getContentType());
+		OrmAttributeMappingProvider mappingProvider = 
+				getMappingFileDefinition().getOrmAttributeMappingProvider(mappingKey);
+		XmlAttributeMapping resourceMapping = mappingProvider.buildResourceMapping();
 		OrmPersistentAttribute persistentAttribute = buildSpecifiedOrmPersistentAttribute(resourceMapping);
 		int index = insertionIndex(persistentAttribute);
 		this.specifiedPersistentAttributes.add(index, persistentAttribute);
@@ -860,7 +875,10 @@ public abstract class AbstractOrmPersistentType
 
 	//not firing change notification so this can be reused in initialize and update
 	protected OrmPersistentAttribute addVirtualPersistentAttribute(JavaAttributeMapping javaAttributeMapping) {
-		XmlAttributeMapping resourceMapping = getJpaPlatform().buildVirtualOrmResourceMappingFromMappingKey(javaAttributeMapping.getKey(), getMapping(), javaAttributeMapping);
+		OrmAttributeMappingProvider mappingProvider = 
+				getMappingFileDefinition().getOrmAttributeMappingProvider(javaAttributeMapping.getKey());
+		XmlAttributeMapping resourceMapping = 
+				mappingProvider.buildVirtualResourceMapping(getMapping(), javaAttributeMapping, getJpaFactory());
 		OrmPersistentAttribute virtualPersistentAttribute = buildVirtualOrmPersistentAttribute(javaAttributeMapping, resourceMapping);
 		this.virtualPersistentAttributes.add(virtualPersistentAttribute);
 		return virtualPersistentAttribute;
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmMappingFileDefinition.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmMappingFileDefinition.java
new file mode 100644
index 0000000000..8169b39f6f
--- /dev/null
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmMappingFileDefinition.java
@@ -0,0 +1,88 @@
+/*******************************************************************************
+ * Copyright (c) 2008, 2009 Oracle. All rights reserved.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0, which accompanies this distribution
+ * and is available at http://www.eclipse.org/legal/epl-v10.html.
+ * 
+ * Contributors:
+ *     Oracle - initial API and implementation
+ ******************************************************************************/
+package org.eclipse.jpt.core.internal.context.orm;
+
+import org.eclipse.core.runtime.content.IContentType;
+import org.eclipse.jpt.core.JpaFactory;
+import org.eclipse.jpt.core.JptCorePlugin;
+import org.eclipse.jpt.core.context.MappingFile;
+import org.eclipse.jpt.core.context.MappingFileDefinition;
+import org.eclipse.jpt.core.context.orm.OrmAttributeMappingProvider;
+import org.eclipse.jpt.core.context.orm.OrmTypeMappingProvider;
+import org.eclipse.jpt.core.context.persistence.MappingFileRef;
+import org.eclipse.jpt.core.internal.platform.AbstractMappingFileDefinition;
+import org.eclipse.jpt.core.resource.xml.JpaXmlResource;
+
+public class GenericOrmMappingFileDefinition
+	extends AbstractMappingFileDefinition
+{
+	// singleton
+	private static final MappingFileDefinition INSTANCE = 
+			new GenericOrmMappingFileDefinition();
+	
+	
+	/**
+	 * Return the singleton
+	 */
+	public static MappingFileDefinition instance() {
+		return INSTANCE;
+	}
+	
+	
+	/**
+	 * Enforce singleton usage
+	 */
+	private GenericOrmMappingFileDefinition() {
+		super();
+	}
+	
+	
+	public IContentType getContentType() {
+		return JptCorePlugin.ORM_XML_CONTENT_TYPE;
+	}
+	
+	public MappingFile buildMappingFile(MappingFileRef parent, JpaXmlResource resource, JpaFactory factory) {
+		return factory.buildMappingFile(parent, resource);
+	}
+	
+	
+	// ********** ORM type mappings **********
+	
+	@Override
+	protected OrmTypeMappingProvider[] buildOrmTypeMappingProviders() {
+		// order should not matter here, but we'll use the same order as for java 
+		// (@see {@link GenericJpaPlatformProvider})
+		return new OrmTypeMappingProvider[] {
+			OrmEntityProvider.instance(),
+			OrmEmbeddableProvider.instance(),
+			OrmMappedSuperclassProvider.instance()};
+	}
+	
+	
+	// ********** ORM attribute mappings **********
+	
+	@Override
+	protected OrmAttributeMappingProvider[] buildOrmAttributeMappingProviders() {
+		// order should not matter here, but we'll use the same order as for java
+		// (@see {@link GenericJpaPlatformProvider})
+		return new OrmAttributeMappingProvider[] {
+			OrmTransientMappingProvider.instance(),
+			OrmIdMappingProvider.instance(),
+			OrmVersionMappingProvider.instance(),
+			OrmBasicMappingProvider.instance(),
+			OrmEmbeddedMappingProvider.instance(),
+			OrmEmbeddedIdMappingProvider.instance(),
+			OrmManyToManyMappingProvider.instance(),
+			OrmManyToOneMappingProvider.instance(),
+			OrmOneToManyMappingProvider.instance(),
+			OrmOneToOneMappingProvider.instance(),
+			OrmNullAttributeMappingProvider.instance()};
+	}
+}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/AbstractMappingFileRef.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/AbstractMappingFileRef.java
index 804ada585f..69c7338b90 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/AbstractMappingFileRef.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/AbstractMappingFileRef.java
@@ -14,6 +14,7 @@ import org.eclipse.core.resources.IFile;
 import org.eclipse.core.runtime.content.IContentType;
 import org.eclipse.jpt.core.JpaStructureNode;
 import org.eclipse.jpt.core.context.MappingFile;
+import org.eclipse.jpt.core.context.MappingFileDefinition;
 import org.eclipse.jpt.core.context.MappingFilePersistenceUnitDefaults;
 import org.eclipse.jpt.core.context.MappingFileRoot;
 import org.eclipse.jpt.core.context.PersistentType;
@@ -160,9 +161,10 @@ public abstract class AbstractMappingFileRef
 	}
 	
 	protected MappingFile buildMappingFile(JpaXmlResource resource) {
-		return this.getJpaPlatform().buildMappingFile(this, resource);
+		MappingFileDefinition mappingFileDef = getJpaPlatform().getMappingFileDefinition(resource.getContentType());
+		return (mappingFileDef == null) ? null : mappingFileDef.buildMappingFile(this, resource, getJpaFactory());
 	}
-
+	
 	@Override
 	public void postUpdate() {
 		super.postUpdate();
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/Generic2_0MappingFileProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/Generic2_0MappingFileProvider.java
deleted file mode 100644
index da7dbb2c1a..0000000000
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/Generic2_0MappingFileProvider.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2009 Oracle. All rights reserved.
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0, which accompanies this distribution
- * and is available at http://www.eclipse.org/legal/epl-v10.html.
- * 
- * Contributors:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.core.internal.jpa2.context;
-
-import org.eclipse.core.runtime.content.IContentType;
-import org.eclipse.jpt.core.JpaFactory;
-import org.eclipse.jpt.core.JptCorePlugin;
-import org.eclipse.jpt.core.context.MappingFile;
-import org.eclipse.jpt.core.context.MappingFileProvider;
-import org.eclipse.jpt.core.context.persistence.MappingFileRef;
-import org.eclipse.jpt.core.internal.jpa2.platform.Generic2_0JpaFactory;
-import org.eclipse.jpt.core.resource.xml.JpaXmlResource;
-
-public class Generic2_0MappingFileProvider
-	implements MappingFileProvider
-{
-	// singleton
-	private static final MappingFileProvider INSTANCE = new Generic2_0MappingFileProvider();
-
-	/**
-	 * Return the singleton.
-	 */
-	public static MappingFileProvider instance() {
-		return INSTANCE;
-	}
-
-	/**
-	 * Ensure single instance.
-	 */
-	private Generic2_0MappingFileProvider() {
-		super();
-	}
-
-	public IContentType getContentType() {
-		return JptCorePlugin.ORM2_0_XML_CONTENT_TYPE;
-	}
-
-	public MappingFile buildMappingFile(MappingFileRef parent, JpaXmlResource resource, JpaFactory factory) {
-		return ((Generic2_0JpaFactory) factory).buildMappingFile2_0(parent, resource);
-	}
-
-}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/GenericOrm2_0MappingFileDefinition.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/GenericOrm2_0MappingFileDefinition.java
new file mode 100644
index 0000000000..1ad3a89e03
--- /dev/null
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/GenericOrm2_0MappingFileDefinition.java
@@ -0,0 +1,104 @@
+/*******************************************************************************
+ * Copyright (c) 2009 Oracle. All rights reserved.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0, which accompanies this distribution
+ * and is available at http://www.eclipse.org/legal/epl-v10.html.
+ * 
+ * Contributors:
+ *     Oracle - initial API and implementation
+ ******************************************************************************/
+package org.eclipse.jpt.core.internal.jpa2.context;
+
+import org.eclipse.core.runtime.content.IContentType;
+import org.eclipse.jpt.core.JpaFactory;
+import org.eclipse.jpt.core.JptCorePlugin;
+import org.eclipse.jpt.core.context.MappingFile;
+import org.eclipse.jpt.core.context.MappingFileDefinition;
+import org.eclipse.jpt.core.context.orm.OrmAttributeMappingProvider;
+import org.eclipse.jpt.core.context.orm.OrmTypeMappingProvider;
+import org.eclipse.jpt.core.context.persistence.MappingFileRef;
+import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmBasicMapping2_0Provider;
+import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmEmbeddableMapping2_0Provider;
+import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmEmbeddedIdMapping2_0Provider;
+import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmEmbeddedMapping2_0Provider;
+import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmEntityMapping2_0Provider;
+import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmIdMapping2_0Provider;
+import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmManyToManyMapping2_0Provider;
+import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmManyToOneMapping2_0Provider;
+import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmMappedSuperclassMapping2_0Provider;
+import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmNullAttributeMapping2_0Provider;
+import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmOneToManyMapping2_0Provider;
+import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmOneToOneMapping2_0Provider;
+import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmTransientMapping2_0Provider;
+import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmVersionMapping2_0Provider;
+import org.eclipse.jpt.core.internal.jpa2.platform.Generic2_0JpaFactory;
+import org.eclipse.jpt.core.internal.platform.AbstractMappingFileDefinition;
+import org.eclipse.jpt.core.resource.xml.JpaXmlResource;
+
+public class GenericOrm2_0MappingFileDefinition
+	extends AbstractMappingFileDefinition
+{
+	// singleton
+	private static final MappingFileDefinition INSTANCE = 
+			new GenericOrm2_0MappingFileDefinition();
+	
+	
+	/**
+	 * Return the singleton
+	 */
+	public static MappingFileDefinition instance() {
+		return INSTANCE;
+	}
+	
+	
+	/**
+	 * Enforce singleton usage
+	 */
+	private GenericOrm2_0MappingFileDefinition() {
+		super();
+	}
+	
+	
+	public IContentType getContentType() {
+		return JptCorePlugin.ORM2_0_XML_CONTENT_TYPE;
+	}
+	
+	public MappingFile buildMappingFile(MappingFileRef parent, JpaXmlResource resource, JpaFactory factory) {
+		return ((Generic2_0JpaFactory) factory).buildMappingFile2_0(parent, resource);
+	}
+	
+	
+	// ********** ORM type mappings **********
+	
+	@Override
+	protected OrmTypeMappingProvider[] buildOrmTypeMappingProviders() {
+		// order should not matter here, but we'll use the same order as for java 
+		// (@see {@link Generic2_0JpaPlatformProvider})
+		return new OrmTypeMappingProvider[] {
+			GenericOrmEntityMapping2_0Provider.instance(),
+			GenericOrmEmbeddableMapping2_0Provider.instance(),
+			GenericOrmMappedSuperclassMapping2_0Provider.instance()};
+	}
+	
+	
+	// ********** ORM attribute mappings **********
+	
+	@Override
+	protected OrmAttributeMappingProvider[] buildOrmAttributeMappingProviders() {
+		// order should not matter here, but we'll use the same order as for java
+		// (@see {@link Generic2_0JpaPlatformProvider})
+		return new OrmAttributeMappingProvider[] {
+			GenericOrmTransientMapping2_0Provider.instance(),
+			//OrmElementCollectionMappingProvider.instance(),
+			GenericOrmIdMapping2_0Provider.instance(),
+			GenericOrmVersionMapping2_0Provider.instance(),
+			GenericOrmBasicMapping2_0Provider.instance(),
+			GenericOrmEmbeddedMapping2_0Provider.instance(),
+			GenericOrmEmbeddedIdMapping2_0Provider.instance(),
+			GenericOrmManyToManyMapping2_0Provider.instance(),
+			GenericOrmManyToOneMapping2_0Provider.instance(),
+			GenericOrmOneToManyMapping2_0Provider.instance(),
+			GenericOrmOneToOneMapping2_0Provider.instance(),
+			GenericOrmNullAttributeMapping2_0Provider.instance()};
+	}
+}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/platform/Generic2_0JpaPlatformFactory.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/platform/Generic2_0JpaPlatformFactory.java
index 1c087ed4f8..4a59d42e83 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/platform/Generic2_0JpaPlatformFactory.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/platform/Generic2_0JpaPlatformFactory.java
@@ -9,14 +9,11 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.internal.jpa2.platform;
 
-import org.eclipse.jpt.core.JpaAnnotationProvider;
-import org.eclipse.jpt.core.JpaFactory;
 import org.eclipse.jpt.core.JpaPlatform;
 import org.eclipse.jpt.core.JpaPlatformFactory;
 import org.eclipse.jpt.core.JpaValidation;
 import org.eclipse.jpt.core.internal.platform.GenericJpaAnnotationProvider;
 import org.eclipse.jpt.core.internal.platform.GenericJpaPlatform;
-import org.eclipse.jpt.core.internal.platform.GenericJpaPlatformProvider;
 
 /**
  * All the state in the JPA platform should be "static" (i.e. unchanging once
@@ -25,7 +22,6 @@ import org.eclipse.jpt.core.internal.platform.GenericJpaPlatformProvider;
 public class Generic2_0JpaPlatformFactory
 	implements JpaPlatformFactory
 {
-
 	/**
 	 * zero-argument constructor
 	 */
@@ -33,23 +29,14 @@ public class Generic2_0JpaPlatformFactory
 		super();
 	}
 	
+	
 	public JpaPlatform buildJpaPlatform(String id) {
 		return new GenericJpaPlatform(
 			id,
-			buildJpaFactory(), 
-			buildJpaAnnotationProvider(), 
-			buildJpaValidation(),
-			GenericJpaPlatformProvider.instance(), 
-			Generic2_0JpaPlatformProvider.instance());
-	}
-	
-	protected JpaFactory buildJpaFactory() {
-		return new Generic2_0JpaFactory();
-	}
-	
-	protected JpaAnnotationProvider buildJpaAnnotationProvider() {
-		return new GenericJpaAnnotationProvider(
-			Generic2_0JpaAnnotationDefinitionProvider.instance());
+			new Generic2_0JpaFactory(), 
+			new GenericJpaAnnotationProvider(Generic2_0JpaAnnotationDefinitionProvider.instance()),
+			Generic2_0JpaPlatformProvider.instance(),
+			buildJpaValidation());
 	}
 	
 	protected JpaValidation buildJpaValidation() {
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/platform/Generic2_0JpaPlatformProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/platform/Generic2_0JpaPlatformProvider.java
index 4bd935ca24..cf9cfff3e2 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/platform/Generic2_0JpaPlatformProvider.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/platform/Generic2_0JpaPlatformProvider.java
@@ -9,126 +9,126 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.internal.jpa2.platform;
 
-import java.util.List;
 import org.eclipse.jpt.core.JpaPlatformProvider;
 import org.eclipse.jpt.core.JpaResourceModelProvider;
-import org.eclipse.jpt.core.context.MappingFileProvider;
-import org.eclipse.jpt.core.context.java.DefaultJavaAttributeMappingProvider;
+import org.eclipse.jpt.core.context.MappingFileDefinition;
 import org.eclipse.jpt.core.context.java.JavaAttributeMappingProvider;
 import org.eclipse.jpt.core.context.java.JavaTypeMappingProvider;
-import org.eclipse.jpt.core.context.orm.OrmAttributeMappingProvider;
-import org.eclipse.jpt.core.context.orm.OrmTypeMappingProvider;
+import org.eclipse.jpt.core.internal.JarResourceModelProvider;
+import org.eclipse.jpt.core.internal.JavaResourceModelProvider;
+import org.eclipse.jpt.core.internal.OrmResourceModelProvider;
+import org.eclipse.jpt.core.internal.PersistenceResourceModelProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaBasicMappingProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaEmbeddableProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaEmbeddedIdMappingProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaEmbeddedMappingProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaEntityProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaIdMappingProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaManyToManyMappingProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaManyToOneMappingProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaMappedSuperclassProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaOneToManyMappingProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaOneToOneMappingProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaTransientMappingProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaVersionMappingProvider;
+import org.eclipse.jpt.core.internal.context.orm.GenericOrmMappingFileDefinition;
 import org.eclipse.jpt.core.internal.jpa2.Orm2_0ResourceModelProvider;
 import org.eclipse.jpt.core.internal.jpa2.Persistence2_0ResourceModelProvider;
-import org.eclipse.jpt.core.internal.jpa2.context.Generic2_0MappingFileProvider;
-import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmBasicMapping2_0Provider;
-import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmEmbeddableMapping2_0Provider;
-import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmEmbeddedIdMapping2_0Provider;
-import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmEmbeddedMapping2_0Provider;
-import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmEntityMapping2_0Provider;
-import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmIdMapping2_0Provider;
-import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmManyToManyMapping2_0Provider;
-import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmManyToOneMapping2_0Provider;
-import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmMappedSuperclassMapping2_0Provider;
-import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmNullAttributeMapping2_0Provider;
-import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmOneToManyMapping2_0Provider;
-import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmOneToOneMapping2_0Provider;
-import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmTransientMapping2_0Provider;
-import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmVersionMapping2_0Provider;
+import org.eclipse.jpt.core.internal.jpa2.context.GenericOrm2_0MappingFileDefinition;
 import org.eclipse.jpt.core.internal.platform.AbstractJpaPlatformProvider;
 
 /**
  * All the state in the JPA platform should be "static" (i.e. unchanging once
  * it is initialized).
  */
-public class Generic2_0JpaPlatformProvider extends AbstractJpaPlatformProvider
+public class Generic2_0JpaPlatformProvider 
+	extends AbstractJpaPlatformProvider
 {
 	public static final String ID = "generic2_0"; //$NON-NLS-1$
-
+	
+	
 	// singleton
-	private static final JpaPlatformProvider INSTANCE = new Generic2_0JpaPlatformProvider();
-
+	private static final JpaPlatformProvider INSTANCE = 
+			new Generic2_0JpaPlatformProvider();
+	
+	
 	/**
-	 * Return the singleton.
+	 * Return the singleton
 	 */
 	public static JpaPlatformProvider instance() {
 		return INSTANCE;
 	}
-
+	
+	
 	/**
-	 * Ensure single instance.
+	 * Enforce singleton usage
 	 */
 	private Generic2_0JpaPlatformProvider() {
 		super();
 	}
-
-
+	
+	
 	// ********** resource models **********
-
+	
 	@Override
-	protected void addResourceModelProvidersTo(List<JpaResourceModelProvider> providers) {
-		providers.add(Persistence2_0ResourceModelProvider.instance());
-		providers.add(Orm2_0ResourceModelProvider.instance());
+	protected JpaResourceModelProvider[] buildResourceModelProviders() {
+		// order should not be important here
+		return new JpaResourceModelProvider[] {
+			JavaResourceModelProvider.instance(),
+			JarResourceModelProvider.instance(),
+			PersistenceResourceModelProvider.instance(),
+			OrmResourceModelProvider.instance(),
+			Persistence2_0ResourceModelProvider.instance(),
+			Orm2_0ResourceModelProvider.instance()};
 	}
-
-
+	
+	
 	// ********** Java type mappings **********
 	
 	@Override
-	protected void addJavaTypeMappingProvidersTo(List<JavaTypeMappingProvider> providers) {
+	protected JavaTypeMappingProvider[] buildNonNullJavaTypeMappingProviders() {
+		// order determined by analyzing order that reference implementation (eclipselink) uses
+		return new JavaTypeMappingProvider[] {
+			JavaEntityProvider.instance(),
+			JavaEmbeddableProvider.instance(),
+			JavaMappedSuperclassProvider.instance()};
 	}
-
-
+	
+	
 	// ********** Java attribute mappings **********
-
-	@Override
-	protected void addJavaAttributeMappingProvidersTo(List<JavaAttributeMappingProvider> providers) {
-		//providers.add(JavaElementCollectionMappingProvider.instance());
-	}
-
-
-	// ********** default Java attribute mappings **********
-
-	@Override
-	protected void addDefaultJavaAttributeMappingProvidersTo(List<DefaultJavaAttributeMappingProvider> providers) {
-	}
-
-	// ********** Mapping File **********
-
-	/**
-	 * Override this to specify more or different mapping file providers.
-	 */
+	
 	@Override
-	protected void addMappingFileProvidersTo(List<MappingFileProvider> providers) {
-		providers.add(Generic2_0MappingFileProvider.instance());
+	protected JavaAttributeMappingProvider[] buildNonNullDefaultJavaAttributeMappingProviders() {
+		// order determined by analyzing order that reference implementation (toplink) uses
+		return new JavaAttributeMappingProvider[] {
+			JavaEmbeddedMappingProvider.instance(),
+			JavaBasicMappingProvider.instance()};
 	}
-
-
-	// ********** ORM type mappings **********
-
+	
 	@Override
-	protected void addOrmTypeMappingProvidersTo(List<OrmTypeMappingProvider> providers) {
-		providers.add(GenericOrmEmbeddableMapping2_0Provider.instance());
-		providers.add(GenericOrmEntityMapping2_0Provider.instance());
-		providers.add(GenericOrmMappedSuperclassMapping2_0Provider.instance());
+	protected JavaAttributeMappingProvider[] buildNonNullSpecifiedJavaAttributeMappingProviders() {
+		// order determined by analyzing order that reference implementation (toplink) uses
+		return new JavaAttributeMappingProvider[] {
+			JavaTransientMappingProvider.instance(),
+			//JavaElementCollectionMappingProvider.instance(),
+			JavaIdMappingProvider.instance(),
+			JavaVersionMappingProvider.instance(),
+			JavaBasicMappingProvider.instance(),
+			JavaEmbeddedMappingProvider.instance(),
+			JavaEmbeddedIdMappingProvider.instance(),
+			JavaManyToManyMappingProvider.instance(),
+			JavaManyToOneMappingProvider.instance(),
+			JavaOneToManyMappingProvider.instance(),
+			JavaOneToOneMappingProvider.instance()};
 	}
-
-
-	// ********** ORM attribute mappings **********
-
+	
+	
+	// ********** Mapping Files **********
+	
 	@Override
-	protected void addOrmAttributeMappingProvidersTo(List<OrmAttributeMappingProvider> providers) {
-		providers.add(GenericOrmBasicMapping2_0Provider.instance());
-		providers.add(GenericOrmIdMapping2_0Provider.instance());
-		//providers.add(OrmElementCollectionMappingProvider.instance());
-		providers.add(GenericOrmEmbeddedIdMapping2_0Provider.instance());
-		providers.add(GenericOrmEmbeddedMapping2_0Provider.instance());
-		providers.add(GenericOrmManyToManyMapping2_0Provider.instance());
-		providers.add(GenericOrmManyToOneMapping2_0Provider.instance());
-		providers.add(GenericOrmOneToManyMapping2_0Provider.instance());
-		providers.add(GenericOrmOneToOneMapping2_0Provider.instance());
-		providers.add(GenericOrmVersionMapping2_0Provider.instance());
-		providers.add(GenericOrmTransientMapping2_0Provider.instance());
-		providers.add(GenericOrmNullAttributeMapping2_0Provider.instance());
+	protected MappingFileDefinition[] buildMappingFileDefinitions() {
+		return new MappingFileDefinition[] {
+			GenericOrmMappingFileDefinition.instance(),
+			GenericOrm2_0MappingFileDefinition.instance()};
 	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/AbstractJpaPlatformProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/AbstractJpaPlatformProvider.java
index 69b35d35fe..0548b18f93 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/AbstractJpaPlatformProvider.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/AbstractJpaPlatformProvider.java
@@ -9,52 +9,46 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.internal.platform;
 
-import java.util.ArrayList;
-import java.util.List;
 import java.util.ListIterator;
-
 import org.eclipse.jpt.core.JpaPlatformProvider;
 import org.eclipse.jpt.core.JpaResourceModelProvider;
-import org.eclipse.jpt.core.context.MappingFileProvider;
-import org.eclipse.jpt.core.context.java.DefaultJavaAttributeMappingProvider;
+import org.eclipse.jpt.core.context.MappingFileDefinition;
 import org.eclipse.jpt.core.context.java.JavaAttributeMappingProvider;
+import org.eclipse.jpt.core.context.java.NullJavaTypeMappingProvider;
+import org.eclipse.jpt.core.context.java.NullDefaultJavaAttributeMappingProvider;
+import org.eclipse.jpt.core.context.java.NullSpecifiedJavaAttributeMappingProvider;
 import org.eclipse.jpt.core.context.java.JavaTypeMappingProvider;
-import org.eclipse.jpt.core.context.orm.OrmAttributeMappingProvider;
-import org.eclipse.jpt.core.context.orm.OrmTypeMappingProvider;
-import org.eclipse.jpt.core.internal.context.java.JavaNullAttributeMappingProvider;
+import org.eclipse.jpt.utility.internal.CollectionTools;
 import org.eclipse.jpt.utility.internal.iterators.ArrayListIterator;
 
 /**
  * All the state in the JPA platform should be "static" (i.e. unchanging once
  * it is initialized).
  */
-public abstract class AbstractJpaPlatformProvider implements JpaPlatformProvider
+public abstract class AbstractJpaPlatformProvider
+	implements JpaPlatformProvider
 {
 	private JpaResourceModelProvider[] resourceModelProviders;
 
 	private JavaTypeMappingProvider[] javaTypeMappingProviders;
 
-	private JavaAttributeMappingProvider[] javaAttributeMappingProviders;
-
-	private MappingFileProvider[] mappingFileProviders;
-
-	private DefaultJavaAttributeMappingProvider[] defaultJavaAttributeMappingProviders;
+	private JavaAttributeMappingProvider[] specifiedJavaAttributeMappingProviders;
 
-	private OrmTypeMappingProvider[] ormTypeMappingProviders;
+	private JavaAttributeMappingProvider[] defaultJavaAttributeMappingProviders;
 
-	private OrmAttributeMappingProvider[] ormAttributeMappingProviders;
+	private MappingFileDefinition[] mappingFileDefinitions;
 
 
 	/**
 	 * zero-argument constructor
 	 */
-	public AbstractJpaPlatformProvider() {
+	protected AbstractJpaPlatformProvider() {
 		super();
 	}
 
 
 	// ********** resource models **********
-
+	
 	public ListIterator<JpaResourceModelProvider> resourceModelProviders() {
 		return new ArrayListIterator<JpaResourceModelProvider>(getResourceModelProviders());
 	}
@@ -65,19 +59,10 @@ public abstract class AbstractJpaPlatformProvider implements JpaPlatformProvider
 		}
 		return this.resourceModelProviders;
 	}
-
-	protected JpaResourceModelProvider[] buildResourceModelProviders() {
-		ArrayList<JpaResourceModelProvider> providers = new ArrayList<JpaResourceModelProvider>();
-		this.addResourceModelProvidersTo(providers);
-		return providers.toArray(new JpaResourceModelProvider[providers.size()]);
-	}
-
-	/**
-	 * Implement this to specify JPA resource model providers.
-	 */
-	protected abstract void addResourceModelProvidersTo(List<JpaResourceModelProvider> providers);
-
-
+	
+	protected abstract JpaResourceModelProvider[] buildResourceModelProviders();
+	
+	
 	// ********** Java type mappings **********
 	
 	public ListIterator<JavaTypeMappingProvider> javaTypeMappingProviders() {
@@ -90,148 +75,114 @@ public abstract class AbstractJpaPlatformProvider implements JpaPlatformProvider
 		}
 		return this.javaTypeMappingProviders;
 	}
-
-	protected JavaTypeMappingProvider[] buildJavaTypeMappingProviders() {
-		ArrayList<JavaTypeMappingProvider> providers = new ArrayList<JavaTypeMappingProvider>();
-		this.addJavaTypeMappingProvidersTo(providers);
-		return providers.toArray(new JavaTypeMappingProvider[providers.size()]);
-	}
-
+	
 	/**
-	 * Implement this to specify type mapping providers.
+	 * Return an array of mapping providers to use for analyzing the mapping of a type given all 
+	 * annotations on it.  The order is important, as once a mapping provider tests positive for an 
+	 * attribute, all following mapping providers are ignored.
+	 * Extenders may either overwrite this method or {@link #buildNonNullJavaTypeMappingProviders()}.
+	 * Doing the former places the additional requirement on the extender to provide a "null"
+	 * mapping provider (@see {@link NullJavaTypeMappingProvider}.)
 	 */
-	protected abstract void addJavaTypeMappingProvidersTo(List<JavaTypeMappingProvider> providers);
-
-
-	// ********** Java attribute mappings **********
-	
-	public ListIterator<JavaAttributeMappingProvider> javaAttributeMappingProviders() {
-		return new ArrayListIterator<JavaAttributeMappingProvider>(getJavaAttributeMappingProviders());
+	protected JavaTypeMappingProvider[] buildJavaTypeMappingProviders() {
+		return CollectionTools.add(
+			buildNonNullJavaTypeMappingProviders(), 
+			NullJavaTypeMappingProvider.instance());
 	}
 	
-	protected synchronized JavaAttributeMappingProvider[] getJavaAttributeMappingProviders() {
-		if (this.javaAttributeMappingProviders == null) {
-			this.javaAttributeMappingProviders = this.buildJavaAttributeMappingProviders();
-		}
-		return this.javaAttributeMappingProviders;
-	}
-
-	protected JavaAttributeMappingProvider[] buildJavaAttributeMappingProviders() {
-		ArrayList<JavaAttributeMappingProvider> providers = new ArrayList<JavaAttributeMappingProvider>();
-		this.addJavaAttributeMappingProvidersTo(providers);
-		return providers.toArray(new JavaAttributeMappingProvider[providers.size()]);
-	}
-
 	/**
-	 * Implement this to specify attribute mapping providers.
+	 * No-op implementation of this method. 
+	 * @see #buildJavaTypeMappingProviders()
 	 */
-	protected abstract void addJavaAttributeMappingProvidersTo(List<JavaAttributeMappingProvider> providers);
-
-
-	// ********** default Java attribute mappings **********
+	protected JavaTypeMappingProvider[] buildNonNullJavaTypeMappingProviders() {
+		return new JavaTypeMappingProvider[0];
+	}
+	
+	
+	// ********** Java attribute mappings **********
 	
-	public ListIterator<DefaultJavaAttributeMappingProvider> defaultJavaAttributeMappingProviders() {
-		return new ArrayListIterator<DefaultJavaAttributeMappingProvider>(getDefaultJavaAttributeMappingProviders());
+	public ListIterator<JavaAttributeMappingProvider> defaultJavaAttributeMappingProviders() {
+		return new ArrayListIterator<JavaAttributeMappingProvider>(getDefaultJavaAttributeMappingProviders());
 	}
 
-	protected synchronized DefaultJavaAttributeMappingProvider[] getDefaultJavaAttributeMappingProviders() {
+	protected synchronized JavaAttributeMappingProvider[] getDefaultJavaAttributeMappingProviders() {
 		if (this.defaultJavaAttributeMappingProviders == null) {
 			this.defaultJavaAttributeMappingProviders = this.buildDefaultJavaAttributeMappingProviders();
 		}
 		return this.defaultJavaAttributeMappingProviders;
 	}
-
-	protected DefaultJavaAttributeMappingProvider[] buildDefaultJavaAttributeMappingProviders() {
-		ArrayList<DefaultJavaAttributeMappingProvider> providers = new ArrayList<DefaultJavaAttributeMappingProvider>();
-		this.addDefaultJavaAttributeMappingProvidersTo(providers);
-		return providers.toArray(new DefaultJavaAttributeMappingProvider[providers.size()]);
-	}
-
+	
 	/**
-	 * Implement this to specify default attribute mapping providers.
+	 * Return an array of mapping providers to use for analyzing the default mapping of an attribute
+	 * in the absence of any annotations.  The order is important, as once a mapping provider tests
+	 * positively for a given attribute, all following mapping providers are ignored.
+	 * Extenders may either overwrite this method or 
+	 * {@link #buildNonNullDefaultJavaAttributeMappingProviders()}.
+	 * Doing the former places the additional requirement on the extender to provide a "null"
+	 * mapping provider (@see {@link NullDefaultJavaAttributeMappingProvider}.)
 	 */
-	protected abstract void addDefaultJavaAttributeMappingProvidersTo(List<DefaultJavaAttributeMappingProvider> providers);
-
+	protected JavaAttributeMappingProvider[] buildDefaultJavaAttributeMappingProviders() {
+		return CollectionTools.add(
+			buildNonNullDefaultJavaAttributeMappingProviders(), 
+			NullDefaultJavaAttributeMappingProvider.instance());
+	}
+	
 	/**
-	 * the "null" attribute mapping is used when the attribute is neither
-	 * modified with a mapping annotation nor mapped by a "default" mapping
+	 * No-op implementation of this method. 
+	 * @see #buildDefaultJavaAttributeMappingProviders()
 	 */
-	protected JavaAttributeMappingProvider getNullAttributeMappingProvider() {
-		return JavaNullAttributeMappingProvider.instance();
+	protected JavaAttributeMappingProvider[] buildNonNullDefaultJavaAttributeMappingProviders() {
+		return new JavaAttributeMappingProvider[0];
 	}
-
-
-	// ********** Mapping File **********
 	
-	public ListIterator<MappingFileProvider> mappingFileProviders() {
-		return new ArrayListIterator<MappingFileProvider>(getMappingFileProviders());
+	public ListIterator<JavaAttributeMappingProvider> specifiedJavaAttributeMappingProviders() {
+		return new ArrayListIterator<JavaAttributeMappingProvider>(
+			getSpecifiedJavaAttributeMappingProviders());
 	}
 	
-	protected synchronized MappingFileProvider[] getMappingFileProviders() {
-		if (this.mappingFileProviders == null) {
-			this.mappingFileProviders = this.buildMappingFileProviders();
+	protected synchronized JavaAttributeMappingProvider[] getSpecifiedJavaAttributeMappingProviders() {
+		if (this.specifiedJavaAttributeMappingProviders == null) {
+			this.specifiedJavaAttributeMappingProviders = this.buildSpecifiedJavaAttributeMappingProviders();
 		}
-		return this.mappingFileProviders;
+		return this.specifiedJavaAttributeMappingProviders;
 	}
-
-	protected MappingFileProvider[] buildMappingFileProviders() {
-		ArrayList<MappingFileProvider> providers = new ArrayList<MappingFileProvider>();
-		this.addMappingFileProvidersTo(providers);
-		return providers.toArray(new MappingFileProvider[providers.size()]);
-	}
-
+	
 	/**
-	 * Implement this to specify mapping file providers.
+	 * Return an array of mapping providers to use for analyzing the specified mapping of an attribute
+	 * given all annotations on it.  The order is important, as once a mapping provider tests
+	 * positively for a given attribute, all following mapping providers are ignored.
+	 * Extenders may either overwrite this method or 
+	 * {@link #buildNonNullSpecifiedJavaAttributeMappingProviders()}.
+	 * Doing the former places the additional requirement on the extender to provide a "null"
+	 * mapping provider (@see {@link NullSpecifiedJavaAttributeMappingProvider}.)
 	 */
-	protected abstract void addMappingFileProvidersTo(List<MappingFileProvider> providers);
-
-
-	// ********** ORM type mappings **********
-	
-	public ListIterator<OrmTypeMappingProvider> ormTypeMappingProviders() {
-		return new ArrayListIterator<OrmTypeMappingProvider>(getOrmTypeMappingProviders());
+	protected JavaAttributeMappingProvider[] buildSpecifiedJavaAttributeMappingProviders() {
+		return CollectionTools.add(
+			buildNonNullSpecifiedJavaAttributeMappingProviders(), 
+			NullSpecifiedJavaAttributeMappingProvider.instance());
 	}
 	
-	protected synchronized OrmTypeMappingProvider[] getOrmTypeMappingProviders() {
-		if (this.ormTypeMappingProviders == null) {
-			this.ormTypeMappingProviders = this.buildOrmTypeMappingProviders();
-		}
-		return this.ormTypeMappingProviders;
-	}
-
-	protected OrmTypeMappingProvider[] buildOrmTypeMappingProviders() {
-		ArrayList<OrmTypeMappingProvider> providers = new ArrayList<OrmTypeMappingProvider>();
-		this.addOrmTypeMappingProvidersTo(providers);
-		return providers.toArray(new OrmTypeMappingProvider[providers.size()]);
-	}
-
 	/**
-	 * Implement this to specify type mapping providers.
+	 * No-op implementation of this method. 
+	 * @see #buildSpecifiedJavaAttributeMappingProviders()
 	 */
-	protected abstract void addOrmTypeMappingProvidersTo(List<OrmTypeMappingProvider> providers);
-
-
-	// ********** ORM attribute mappings **********
-
-	public ListIterator<OrmAttributeMappingProvider> ormAttributeMappingProviders() {
-		return new ArrayListIterator<OrmAttributeMappingProvider>(getOrmAttributeMappingProviders());
+	protected JavaAttributeMappingProvider[] buildNonNullSpecifiedJavaAttributeMappingProviders() {
+		return new JavaAttributeMappingProvider[0];
 	}
-
-	protected synchronized OrmAttributeMappingProvider[] getOrmAttributeMappingProviders() {
-		if (this.ormAttributeMappingProviders == null) {
-			this.ormAttributeMappingProviders = this.buildOrmAttributeMappingProviders();
-		}
-		return this.ormAttributeMappingProviders;
+	
+	
+	// ********** Mapping Files **********
+	
+	public ListIterator<MappingFileDefinition> mappingFileDefinitions() {
+		return new ArrayListIterator<MappingFileDefinition>(getMappingFileDefinitions());
 	}
-
-	protected OrmAttributeMappingProvider[] buildOrmAttributeMappingProviders() {
-		ArrayList<OrmAttributeMappingProvider> providers = new ArrayList<OrmAttributeMappingProvider>();
-		this.addOrmAttributeMappingProvidersTo(providers);
-		return providers.toArray(new OrmAttributeMappingProvider[providers.size()]);
+	
+	protected synchronized MappingFileDefinition[] getMappingFileDefinitions() {
+		if (this.mappingFileDefinitions == null) {
+			this.mappingFileDefinitions = this.buildMappingFileDefinitions();
+		}
+		return this.mappingFileDefinitions;
 	}
-
-	/**
-	 * Implement this to specify attribute mapping providers.
-	 */
-	protected abstract void addOrmAttributeMappingProvidersTo(List<OrmAttributeMappingProvider> providers);
+	
+	protected abstract MappingFileDefinition[] buildMappingFileDefinitions();
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/AbstractMappingFileDefinition.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/AbstractMappingFileDefinition.java
new file mode 100644
index 0000000000..8355a1486c
--- /dev/null
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/AbstractMappingFileDefinition.java
@@ -0,0 +1,95 @@
+/*******************************************************************************
+ *  Copyright (c) 2009  Oracle. 
+ *  All rights reserved.  This program and the accompanying materials are 
+ *  made available under the terms of the Eclipse Public License v1.0 which 
+ *  accompanies this distribution, and is available at 
+ *  http://www.eclipse.org/legal/epl-v10.html
+ *  
+ *  Contributors: 
+ *  	Oracle - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jpt.core.internal.platform;
+
+import java.util.ListIterator;
+import org.eclipse.jpt.core.context.MappingFileDefinition;
+import org.eclipse.jpt.core.context.orm.OrmAttributeMappingProvider;
+import org.eclipse.jpt.core.context.orm.OrmTypeMappingProvider;
+import org.eclipse.jpt.utility.internal.CollectionTools;
+import org.eclipse.jpt.utility.internal.iterators.ArrayListIterator;
+
+/**
+ * All the state in the definition should be "static" (i.e. unchanging once it is initialized).
+ */
+public abstract class AbstractMappingFileDefinition
+	implements MappingFileDefinition
+{
+	private OrmTypeMappingProvider[] ormTypeMappingProviders;
+
+	private OrmAttributeMappingProvider[] ormAttributeMappingProviders;
+	
+	
+	/**
+	 * zero-argument constructor
+	 */
+	protected AbstractMappingFileDefinition() {
+		super();
+	}
+	
+	
+	// ********** ORM type mappings **********
+	
+	public OrmTypeMappingProvider getOrmTypeMappingProvider(String mappingKey) {
+		for (OrmTypeMappingProvider provider : CollectionTools.iterable(ormTypeMappingProviders())) {
+			if (provider.getKey() == mappingKey) {
+				return provider;
+			}
+		}
+		throw new IllegalArgumentException("Illegal type mapping key: " + mappingKey); //$NON-NLS-1$
+	}
+	
+	public ListIterator<OrmTypeMappingProvider> ormTypeMappingProviders() {
+		return new ArrayListIterator<OrmTypeMappingProvider>(getOrmTypeMappingProviders());
+	}
+	
+	protected synchronized OrmTypeMappingProvider[] getOrmTypeMappingProviders() {
+		if (this.ormTypeMappingProviders == null) {
+			this.ormTypeMappingProviders = this.buildOrmTypeMappingProviders();
+		}
+		return this.ormTypeMappingProviders;
+	}
+	
+	/**
+	 * Return an array of mapping providers to use for types in mapping files of this type.  
+	 * The order is unimportant.
+	 */
+	protected abstract OrmTypeMappingProvider[] buildOrmTypeMappingProviders();
+	
+	
+	// ********** ORM attribute mappings **********
+	
+	public OrmAttributeMappingProvider getOrmAttributeMappingProvider(String mappingKey) {
+		for (OrmAttributeMappingProvider provider : CollectionTools.iterable(ormAttributeMappingProviders())) {
+			if (provider.getKey() == mappingKey) {
+				return provider;
+			}
+		}
+		throw new IllegalArgumentException("Illegal type mapping key: " + mappingKey); //$NON-NLS-1$
+	}
+	
+	public ListIterator<OrmAttributeMappingProvider> ormAttributeMappingProviders() {
+		return new ArrayListIterator<OrmAttributeMappingProvider>(getOrmAttributeMappingProviders());
+	}
+	
+	protected synchronized OrmAttributeMappingProvider[] getOrmAttributeMappingProviders() {
+		if (this.ormAttributeMappingProviders == null) {
+			this.ormAttributeMappingProviders = this.buildOrmAttributeMappingProviders();
+		}
+		return this.ormAttributeMappingProviders;
+	}
+	
+	/**
+	 * Return an array of mapping providers to use for attributes in mapping files of this type.  
+	 * The order is unimportant.
+	 */
+	protected abstract OrmAttributeMappingProvider[] buildOrmAttributeMappingProviders();
+}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/GenericJpaPlatform.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/GenericJpaPlatform.java
index b2864d8f4d..d79e3f3173 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/GenericJpaPlatform.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/GenericJpaPlatform.java
@@ -23,9 +23,7 @@ import org.eclipse.jpt.core.JpaProject;
 import org.eclipse.jpt.core.JpaResourceModel;
 import org.eclipse.jpt.core.JpaResourceModelProvider;
 import org.eclipse.jpt.core.JpaValidation;
-import org.eclipse.jpt.core.context.MappingFile;
-import org.eclipse.jpt.core.context.MappingFileProvider;
-import org.eclipse.jpt.core.context.java.DefaultJavaAttributeMappingProvider;
+import org.eclipse.jpt.core.context.MappingFileDefinition;
 import org.eclipse.jpt.core.context.java.JavaAttributeMapping;
 import org.eclipse.jpt.core.context.java.JavaAttributeMappingProvider;
 import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;
@@ -34,27 +32,21 @@ import org.eclipse.jpt.core.context.java.JavaTypeMapping;
 import org.eclipse.jpt.core.context.java.JavaTypeMappingProvider;
 import org.eclipse.jpt.core.context.orm.OrmAttributeMapping;
 import org.eclipse.jpt.core.context.orm.OrmAttributeMappingProvider;
+import org.eclipse.jpt.core.context.orm.NullOrmAttributeMappingProvider;
 import org.eclipse.jpt.core.context.orm.OrmPersistentAttribute;
 import org.eclipse.jpt.core.context.orm.OrmPersistentType;
 import org.eclipse.jpt.core.context.orm.OrmTypeMapping;
 import org.eclipse.jpt.core.context.orm.OrmTypeMappingProvider;
-import org.eclipse.jpt.core.context.persistence.MappingFileRef;
-import org.eclipse.jpt.core.internal.context.java.JavaNullAttributeMappingProvider;
-import org.eclipse.jpt.core.internal.context.orm.OrmNullAttributeMappingProvider;
 import org.eclipse.jpt.core.internal.utility.PlatformTools;
 import org.eclipse.jpt.core.internal.utility.jdt.DefaultAnnotationEditFormatter;
 import org.eclipse.jpt.core.resource.orm.XmlAttributeMapping;
 import org.eclipse.jpt.core.resource.orm.XmlTypeMapping;
-import org.eclipse.jpt.core.resource.xml.JpaXmlResource;
 import org.eclipse.jpt.core.utility.jdt.AnnotationEditFormatter;
 import org.eclipse.jpt.db.ConnectionProfileFactory;
 import org.eclipse.jpt.db.DatabaseFinder;
 import org.eclipse.jpt.db.JptDbPlugin;
 import org.eclipse.jpt.utility.internal.CollectionTools;
-import org.eclipse.jpt.utility.internal.iterators.ArrayListIterator;
-import org.eclipse.jpt.utility.internal.iterators.CompositeListIterator;
 import org.eclipse.jpt.utility.internal.iterators.FilteringIterator;
-import org.eclipse.jpt.utility.internal.iterators.TransformationListIterator;
 
 /**
  * All the state in the JPA platform should be "static" (i.e. unchanging once
@@ -63,26 +55,27 @@ import org.eclipse.jpt.utility.internal.iterators.TransformationListIterator;
 public class GenericJpaPlatform
 	implements JpaPlatform
 {
-
 	private final String id;
-
+	
 	private final JpaFactory jpaFactory;
-
+	
 	private final JpaAnnotationProvider annotationProvider;
-
-	private final JpaPlatformProvider[] platformProviders;
+	
+	private final JpaPlatformProvider platformProvider;
 	
 	private final JpaValidation jpaValidation;
 	
-	public GenericJpaPlatform(String id, JpaFactory jpaFactory, JpaAnnotationProvider jpaAnnotationProvider, JpaValidation jpaValidation, JpaPlatformProvider... platformProviders) {
+	
+	public GenericJpaPlatform(String id, JpaFactory jpaFactory, JpaAnnotationProvider jpaAnnotationProvider, JpaPlatformProvider platformProvider, JpaValidation jpaValidation) {
 		super();
 		this.id = id;
 		this.jpaFactory = jpaFactory;
 		this.annotationProvider = jpaAnnotationProvider;
 		this.jpaValidation = jpaValidation;
-		this.platformProviders = platformProviders;
+		this.platformProvider = platformProvider;
 	}
-
+	
+	
 	public String getId() {
 		return this.id;
 	}
@@ -97,10 +90,11 @@ public class GenericJpaPlatform
 	
 	// ********** platform providers **********
 	
-	protected ListIterator<JpaPlatformProvider> platformProviders() {
-		return new ArrayListIterator<JpaPlatformProvider>(this.platformProviders);
+	protected JpaPlatformProvider getPlatformProvider() {
+		return this.platformProvider;
 	}
-
+	
+	
 	// ********** JPA file/resource models **********
 
 	public JpaFile buildJpaFile(JpaProject jpaProject, IFile file) {
@@ -132,16 +126,10 @@ public class GenericJpaPlatform
 	}
 
 	protected ListIterator<JpaResourceModelProvider> resourceModelProviders() {
-		return new CompositeListIterator<JpaResourceModelProvider> ( 
-			new TransformationListIterator<JpaPlatformProvider, ListIterator<JpaResourceModelProvider>>(this.platformProviders()) {
-				@Override
-				protected ListIterator<JpaResourceModelProvider> transform(JpaPlatformProvider platformProvider) {
-					return platformProvider.resourceModelProviders();
-				}
-			}
-		);
+		return this.platformProvider.resourceModelProviders();
 	}
-
+	
+	
 	// ********** Java annotations **********
 
 	public JpaAnnotationProvider getAnnotationProvider() {
@@ -169,14 +157,7 @@ public class GenericJpaPlatform
 	}
 
 	protected ListIterator<JavaTypeMappingProvider> javaTypeMappingProviders() {
-		return new CompositeListIterator<JavaTypeMappingProvider> ( 
-			new TransformationListIterator<JpaPlatformProvider, ListIterator<JavaTypeMappingProvider>>(this.platformProviders()) {
-				@Override
-				protected ListIterator<JavaTypeMappingProvider> transform(JpaPlatformProvider platformProvider) {
-					return platformProvider.javaTypeMappingProviders();
-				}
-			}
-		);
+		return this.platformProvider.javaTypeMappingProviders();
 	}
 
 	public JavaTypeMapping buildJavaTypeMappingFromAnnotation(String annotationName, JavaPersistentType type) {
@@ -194,200 +175,63 @@ public class GenericJpaPlatform
 
 	
 	// ********** Java attribute mappings **********
-
-	public JavaAttributeMapping buildJavaAttributeMappingFromMappingKey(String key, JavaPersistentAttribute attribute) {
-		return this.getJavaAttributeMappingProviderForMappingKey(key).buildMapping(attribute, this.jpaFactory);
-	}
-
-	protected JavaAttributeMappingProvider getJavaAttributeMappingProviderForMappingKey(String key) {
-		for (JavaAttributeMappingProvider provider : CollectionTools.iterable(javaAttributeMappingProviders())) {
-			if (provider.getKey() == key) {
-				return provider;
-			}
-		}
-		throw new IllegalArgumentException("Illegal attribute mapping key: " + key); //$NON-NLS-1$
-	}
-
-	protected ListIterator<JavaAttributeMappingProvider> javaAttributeMappingProviders() {
-		return new CompositeListIterator<JavaAttributeMappingProvider> ( 
-			new TransformationListIterator<JpaPlatformProvider, ListIterator<JavaAttributeMappingProvider>>(this.platformProviders()) {
-				@Override
-				protected ListIterator<JavaAttributeMappingProvider> transform(JpaPlatformProvider platformProvider) {
-					return platformProvider.javaAttributeMappingProviders();
-				}
-			}
-		);
-	}
-
-	public JavaAttributeMapping buildJavaAttributeMappingFromAnnotation(String annotationName, JavaPersistentAttribute attribute) {
-		return this.getJavaAttributeMappingProviderForAnnotation(annotationName).buildMapping(attribute, this.jpaFactory);
-	}
-
-	protected JavaAttributeMappingProvider getJavaAttributeMappingProviderForAnnotation(String annotationName) {
-		for (JavaAttributeMappingProvider provider : CollectionTools.iterable(javaAttributeMappingProviders())) {
-			if (provider.getAnnotationName() == annotationName) {
-				return provider;
-			}
-		}
-		throw new IllegalArgumentException("Illegal annotation name: " + annotationName); //$NON-NLS-1$
-	}
-
-	// ********** default Java attribute mappings **********
-
-	public JavaAttributeMapping buildDefaultJavaAttributeMapping(JavaPersistentAttribute attribute) {
-		return this.getDefaultJavaAttributeMappingProvider(attribute).buildMapping(attribute, this.jpaFactory);
-	}
-
-	public String getDefaultJavaAttributeMappingKey(JavaPersistentAttribute attribute) {
-		return this.getDefaultJavaAttributeMappingProvider(attribute).getKey();
-	}
 	
-	protected ListIterator<DefaultJavaAttributeMappingProvider> defaultJavaAttributeMappingProviders() {
-		return new CompositeListIterator<DefaultJavaAttributeMappingProvider> ( 
-			new TransformationListIterator<JpaPlatformProvider, ListIterator<DefaultJavaAttributeMappingProvider>>(this.platformProviders()) {
-				@Override
-				protected ListIterator<DefaultJavaAttributeMappingProvider> transform(JpaPlatformProvider platformProvider) {
-					return platformProvider.defaultJavaAttributeMappingProviders();
-				}
-			}
-		);
-	}
-
-	protected JavaAttributeMappingProvider getDefaultJavaAttributeMappingProvider(JavaPersistentAttribute attribute) {
-		for (DefaultJavaAttributeMappingProvider provider : CollectionTools.iterable(this.defaultJavaAttributeMappingProviders())) {
+	public JavaAttributeMappingProvider getDefaultJavaAttributeMappingProvider(
+			JavaPersistentAttribute attribute) {
+		for (JavaAttributeMappingProvider provider : 
+				CollectionTools.iterable(defaultJavaAttributeMappingProviders())) {
 			if (provider.defaultApplies(attribute)) {
 				return provider;
 			}
 		}
-		return this.getNullAttributeMappingProvider();
-	}
-
-	/**
-	 * the "null" attribute mapping is used when the attribute is neither
-	 * modified with a mapping annotation nor mapped by a "default" mapping
-	 */
-	protected JavaAttributeMappingProvider getNullAttributeMappingProvider() {
-		return JavaNullAttributeMappingProvider.instance();
+		throw new IllegalStateException("There must be a mapping provider for all attributes"); //$NON-NLS-1$
 	}
-
-
-	// ********** Mapping File **********
-
-	public MappingFile buildMappingFile(MappingFileRef parent, JpaXmlResource resource) {
-		return this.getMappingFileProviderForResourceType(resource.getContentType()).buildMappingFile(parent, resource, this.jpaFactory);
+	
+	protected ListIterator<JavaAttributeMappingProvider> defaultJavaAttributeMappingProviders() {
+		return this.platformProvider.defaultJavaAttributeMappingProviders();
 	}
-
-	protected MappingFileProvider getMappingFileProviderForResourceType(IContentType contentType) {
-		for (MappingFileProvider provider : CollectionTools.iterable(this.mappingFileProviders())) {
-			if (provider.getContentType().equals(contentType)) {
+	
+	public JavaAttributeMappingProvider getSpecifiedJavaAttributeMappingProvider(
+			JavaPersistentAttribute attribute) {
+		for (JavaAttributeMappingProvider provider : 
+				CollectionTools.iterable(specifiedJavaAttributeMappingProviders())) {
+			if (provider.specifiedApplies(attribute)) {
 				return provider;
 			}
 		}
-		throw new IllegalArgumentException("Illegal mapping file content type: " + contentType); //$NON-NLS-1$
+		throw new IllegalStateException("There must be a mapping provider for all attributes"); //$NON-NLS-1$
 	}
 	
-	protected ListIterator<MappingFileProvider> mappingFileProviders() {
-		return new CompositeListIterator<MappingFileProvider> ( 
-			new TransformationListIterator<JpaPlatformProvider, ListIterator<MappingFileProvider>>(this.platformProviders()) {
-				@Override
-				protected ListIterator<MappingFileProvider> transform(JpaPlatformProvider platformProvider) {
-					return platformProvider.mappingFileProviders();
-				}
-			}
-		);
-	}
-
-
-	// ********** ORM type mappings **********
-
-	public XmlTypeMapping buildOrmResourceTypeMapping(String key, IContentType contentType) {
-		return this.getOrmTypeMappingProviderForMappingKey(contentType, key).buildResourceMapping();
+	protected ListIterator<JavaAttributeMappingProvider> specifiedJavaAttributeMappingProviders() {
+		return this.platformProvider.specifiedJavaAttributeMappingProviders();
 	}
 	
-	public OrmTypeMapping buildOrmTypeMappingFromMappingKey(OrmPersistentType type, XmlTypeMapping resourceMapping) {
-		return this.getOrmTypeMappingProviderForMappingKey(type.getContentType(), resourceMapping.getMappingKey()).buildMapping(type, resourceMapping, this.jpaFactory);
-	}
-
-	protected OrmTypeMappingProvider getOrmTypeMappingProviderForMappingKey(IContentType contentType, String key) {
-		for (OrmTypeMappingProvider provider : CollectionTools.iterable(this.ormTypeMappingProviders(key))) {
-			if (provider.getContentType().isKindOf(contentType)) {
+	public JavaAttributeMappingProvider getSpecifiedJavaAttributeMappingProvider(String mappingKey) {
+		for (JavaAttributeMappingProvider provider : CollectionTools.iterable(specifiedJavaAttributeMappingProviders())) {
+			if (provider.getKey() == mappingKey) {
 				return provider;
 			}
 		}
-		if (contentType.getBaseType() != null) {
-			return getOrmTypeMappingProviderForMappingKey(contentType.getBaseType(), key);
-		}
-		throw new IllegalArgumentException("Illegal type mapping key: " + key); //$NON-NLS-1$
-	}
-	
-	protected Iterator<OrmTypeMappingProvider> ormTypeMappingProviders(final String key) {
-		return new FilteringIterator<OrmTypeMappingProvider, OrmTypeMappingProvider>(ormTypeMappingProviders()) {
-			@Override
-			protected boolean accept(OrmTypeMappingProvider o) {
-				return o.getKey() == key;
-			}
-		};
-	}
-
-	protected ListIterator<OrmTypeMappingProvider> ormTypeMappingProviders() {
-		return new CompositeListIterator<OrmTypeMappingProvider> ( 
-			new TransformationListIterator<JpaPlatformProvider, ListIterator<OrmTypeMappingProvider>>(this.platformProviders()) {
-				@Override
-				protected ListIterator<OrmTypeMappingProvider> transform(JpaPlatformProvider platformProvider) {
-					return platformProvider.ormTypeMappingProviders();
-				}
-			}
-		);
+		throw new IllegalArgumentException("Illegal attribute mapping key: " + mappingKey); //$NON-NLS-1$
 	}
 	
 
-	// ********** ORM attribute mappings **********
+	// ********** Mapping Files **********
 	
-	public XmlAttributeMapping buildOrmResourceAttributeMapping(String key, IContentType contentType) {
-		return this.getOrmAttributeMappingProviderForMappingKey(contentType, key).buildResourceMapping();
-	}
-	
-	public OrmAttributeMapping buildOrmAttributeMappingFromMappingKey(OrmPersistentAttribute attribute, XmlAttributeMapping resourceMapping) {
-		return this.getOrmAttributeMappingProviderForMappingKey(attribute.getContentType(), resourceMapping.getMappingKey()).buildMapping(attribute, resourceMapping, this.jpaFactory);
-	}
-
-	public XmlAttributeMapping buildVirtualOrmResourceMappingFromMappingKey(String key, OrmTypeMapping ormTypeMapping, JavaAttributeMapping javaAttributeMapping) {
-		return this.getOrmAttributeMappingProviderForMappingKey(ormTypeMapping.getContentType(), key).buildVirtualResourceMapping(ormTypeMapping, javaAttributeMapping, this.jpaFactory);
-	}
-
-	protected OrmAttributeMappingProvider getOrmAttributeMappingProviderForMappingKey(IContentType contentType, String key) {
-		for (OrmAttributeMappingProvider provider : CollectionTools.iterable(this.ormAttributeMappingProviders(key))) {
-			if (provider.getContentType().isKindOf(contentType)) {
-				return provider;
+	public MappingFileDefinition getMappingFileDefinition(IContentType contentType) {
+		for (MappingFileDefinition mappingFileDef : CollectionTools.iterable(mappingFileDefinitions())) {
+			if (mappingFileDef.getContentType().isKindOf(contentType)) {
+				return mappingFileDef;
 			}
 		}
-		if (contentType.getBaseType() != null) {
-			return getOrmAttributeMappingProviderForMappingKey(contentType.getBaseType(), key);
-		}
-		return OrmNullAttributeMappingProvider.instance();
+		throw new IllegalArgumentException("Illegal mapping file content type: " + contentType); //$NON-NLS-1$
 	}
 	
-	protected Iterator<OrmAttributeMappingProvider> ormAttributeMappingProviders(final String key) {
-		return new FilteringIterator<OrmAttributeMappingProvider, OrmAttributeMappingProvider>(ormAttributeMappingProviders()) {
-			@Override
-			protected boolean accept(OrmAttributeMappingProvider o) {
-				return o.getKey() == key;
-			}
-		};
+	protected ListIterator<MappingFileDefinition> mappingFileDefinitions() {
+		return this.platformProvider.mappingFileDefinitions();
 	}
-
-	protected ListIterator<OrmAttributeMappingProvider> ormAttributeMappingProviders() {
-		return new CompositeListIterator<OrmAttributeMappingProvider> ( 
-			new TransformationListIterator<JpaPlatformProvider, ListIterator<OrmAttributeMappingProvider>>(this.platformProviders()) {
-				@Override
-				protected ListIterator<OrmAttributeMappingProvider> transform(JpaPlatformProvider platformProvider) {
-					return platformProvider.ormAttributeMappingProviders();
-				}
-			}
-		);
-	}
-
-
+	
+	
 	// ********** database **********
 
 	public ConnectionProfileFactory getConnectionProfileFactory() {
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/GenericJpaPlatformFactory.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/GenericJpaPlatformFactory.java
index ae3fbd0cf9..30c8085a34 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/GenericJpaPlatformFactory.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/GenericJpaPlatformFactory.java
@@ -9,12 +9,8 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.internal.platform;
 
-import org.eclipse.jpt.core.JpaAnnotationDefinitionProvider;
-import org.eclipse.jpt.core.JpaAnnotationProvider;
-import org.eclipse.jpt.core.JpaFactory;
 import org.eclipse.jpt.core.JpaPlatform;
 import org.eclipse.jpt.core.JpaPlatformFactory;
-import org.eclipse.jpt.core.JpaPlatformProvider;
 import org.eclipse.jpt.core.JpaValidation;
 
 /**
@@ -24,7 +20,6 @@ import org.eclipse.jpt.core.JpaValidation;
 public class GenericJpaPlatformFactory
 	implements JpaPlatformFactory
 {
-
 	/**
 	 * zero-argument constructor
 	 */
@@ -35,30 +30,12 @@ public class GenericJpaPlatformFactory
 	public JpaPlatform buildJpaPlatform(String id) {
 		return new GenericJpaPlatform(
 			id,
-			this.buildJpaFactory(), 
-			this.buildJpaAnnotationProvider(), 
-			this.buildJpaValidation(),
-			this.platformProviders());
-	}
-	
-	protected JpaFactory buildJpaFactory() {
-		return new GenericJpaFactory();
+			new GenericJpaFactory(), 
+			new GenericJpaAnnotationProvider(GenericJpaAnnotationDefinitionProvider.instance()),
+			GenericJpaPlatformProvider.instance(), 
+			this.buildJpaValidation());
 	}
 	
-	protected JpaAnnotationProvider buildJpaAnnotationProvider() {
-		return new GenericJpaAnnotationProvider(this.annotationDefinitionProvider());
-	}
-
-	protected JpaPlatformProvider[] platformProviders() {
-		JpaPlatformProvider[] platformProviders =  {
-			GenericJpaPlatformProvider.instance()
-		};
-		return platformProviders;
-	}
-
-	protected JpaAnnotationDefinitionProvider annotationDefinitionProvider() {
-		return GenericJpaAnnotationDefinitionProvider.instance();
-	}
 	
 	protected JpaValidation buildJpaValidation() {
 		return new JpaValidation() {
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/GenericJpaPlatformProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/GenericJpaPlatformProvider.java
index 92692ae51b..98d43f7a25 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/GenericJpaPlatformProvider.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/GenericJpaPlatformProvider.java
@@ -9,21 +9,15 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.internal.platform;
 
-import java.util.List;
-
 import org.eclipse.jpt.core.JpaPlatformProvider;
 import org.eclipse.jpt.core.JpaResourceModelProvider;
-import org.eclipse.jpt.core.context.MappingFileProvider;
-import org.eclipse.jpt.core.context.java.DefaultJavaAttributeMappingProvider;
+import org.eclipse.jpt.core.context.MappingFileDefinition;
 import org.eclipse.jpt.core.context.java.JavaAttributeMappingProvider;
 import org.eclipse.jpt.core.context.java.JavaTypeMappingProvider;
-import org.eclipse.jpt.core.context.orm.OrmAttributeMappingProvider;
-import org.eclipse.jpt.core.context.orm.OrmTypeMappingProvider;
 import org.eclipse.jpt.core.internal.JarResourceModelProvider;
 import org.eclipse.jpt.core.internal.JavaResourceModelProvider;
 import org.eclipse.jpt.core.internal.OrmResourceModelProvider;
 import org.eclipse.jpt.core.internal.PersistenceResourceModelProvider;
-import org.eclipse.jpt.core.internal.context.GenericMappingFileProvider;
 import org.eclipse.jpt.core.internal.context.java.JavaBasicMappingProvider;
 import org.eclipse.jpt.core.internal.context.java.JavaEmbeddableProvider;
 import org.eclipse.jpt.core.internal.context.java.JavaEmbeddedIdMappingProvider;
@@ -33,132 +27,99 @@ import org.eclipse.jpt.core.internal.context.java.JavaIdMappingProvider;
 import org.eclipse.jpt.core.internal.context.java.JavaManyToManyMappingProvider;
 import org.eclipse.jpt.core.internal.context.java.JavaManyToOneMappingProvider;
 import org.eclipse.jpt.core.internal.context.java.JavaMappedSuperclassProvider;
-import org.eclipse.jpt.core.internal.context.java.JavaNullTypeMappingProvider;
 import org.eclipse.jpt.core.internal.context.java.JavaOneToManyMappingProvider;
 import org.eclipse.jpt.core.internal.context.java.JavaOneToOneMappingProvider;
 import org.eclipse.jpt.core.internal.context.java.JavaTransientMappingProvider;
 import org.eclipse.jpt.core.internal.context.java.JavaVersionMappingProvider;
-import org.eclipse.jpt.core.internal.context.orm.OrmBasicMappingProvider;
-import org.eclipse.jpt.core.internal.context.orm.OrmEmbeddableProvider;
-import org.eclipse.jpt.core.internal.context.orm.OrmEmbeddedIdMappingProvider;
-import org.eclipse.jpt.core.internal.context.orm.OrmEmbeddedMappingProvider;
-import org.eclipse.jpt.core.internal.context.orm.OrmEntityProvider;
-import org.eclipse.jpt.core.internal.context.orm.OrmIdMappingProvider;
-import org.eclipse.jpt.core.internal.context.orm.OrmManyToManyMappingProvider;
-import org.eclipse.jpt.core.internal.context.orm.OrmManyToOneMappingProvider;
-import org.eclipse.jpt.core.internal.context.orm.OrmMappedSuperclassProvider;
-import org.eclipse.jpt.core.internal.context.orm.OrmOneToManyMappingProvider;
-import org.eclipse.jpt.core.internal.context.orm.OrmOneToOneMappingProvider;
-import org.eclipse.jpt.core.internal.context.orm.OrmTransientMappingProvider;
-import org.eclipse.jpt.core.internal.context.orm.OrmVersionMappingProvider;
+import org.eclipse.jpt.core.internal.context.orm.GenericOrmMappingFileDefinition;
 
 /**
  * All the state in the JPA platform should be "static" (i.e. unchanging once
  * it is initialized).
  */
-public class GenericJpaPlatformProvider extends AbstractJpaPlatformProvider
+public class GenericJpaPlatformProvider
+	extends AbstractJpaPlatformProvider
 {
 	public static final String ID = "generic"; //$NON-NLS-1$
-
+	
 	// singleton
-	private static final JpaPlatformProvider INSTANCE = new GenericJpaPlatformProvider();
-
+	private static final JpaPlatformProvider INSTANCE = 
+		new GenericJpaPlatformProvider();
+	
+	
 	/**
 	 * Return the singleton.
 	 */
 	public static JpaPlatformProvider instance() {
 		return INSTANCE;
 	}
-
+	
+	
 	/**
-	 * Ensure single instance.
+	 * Enforce singleton usage
 	 */
 	private GenericJpaPlatformProvider() {
 		super();
 	}
-
-
+	
+	
 	// ********** resource models **********
-
+	
 	@Override
-	protected void addResourceModelProvidersTo(List<JpaResourceModelProvider> providers) {
-		providers.add(JavaResourceModelProvider.instance());
-		providers.add(PersistenceResourceModelProvider.instance());
-		providers.add(OrmResourceModelProvider.instance());
-		providers.add(JarResourceModelProvider.instance());
+	protected JpaResourceModelProvider[] buildResourceModelProviders() {
+		// order should not be important here
+		return new JpaResourceModelProvider[] {
+			JavaResourceModelProvider.instance(),
+			JarResourceModelProvider.instance(),
+			PersistenceResourceModelProvider.instance(),
+			OrmResourceModelProvider.instance()};
 	}
-
-
+	
+	
 	// ********** Java type mappings **********
 	
 	@Override
-	protected void addJavaTypeMappingProvidersTo(List<JavaTypeMappingProvider> providers) {
-		providers.add(JavaEntityProvider.instance());
-		providers.add(JavaMappedSuperclassProvider.instance());
-		providers.add(JavaEmbeddableProvider.instance());
-		providers.add(JavaNullTypeMappingProvider.instance());
+	protected JavaTypeMappingProvider[] buildNonNullJavaTypeMappingProviders() {
+		// order determined by analyzing order that reference implementation (toplink) uses
+		return new JavaTypeMappingProvider[] {
+			JavaEntityProvider.instance(),
+			JavaEmbeddableProvider.instance(),
+			JavaMappedSuperclassProvider.instance()};
 	}
-
-
+	
+	
 	// ********** Java attribute mappings **********
-
-	@Override
-	protected void addJavaAttributeMappingProvidersTo(List<JavaAttributeMappingProvider> providers) {
-		providers.add(JavaBasicMappingProvider.instance());
-		providers.add(JavaEmbeddedMappingProvider.instance());
-		providers.add(JavaEmbeddedIdMappingProvider.instance());
-		providers.add(JavaIdMappingProvider.instance());
-		providers.add(JavaManyToManyMappingProvider.instance());
-		providers.add(JavaManyToOneMappingProvider.instance());
-		providers.add(JavaOneToManyMappingProvider.instance());
-		providers.add(JavaOneToOneMappingProvider.instance());
-		providers.add(JavaTransientMappingProvider.instance());
-		providers.add(JavaVersionMappingProvider.instance());
-	}
-
-
-	// ********** default Java attribute mappings **********
-
-	@Override
-	protected void addDefaultJavaAttributeMappingProvidersTo(List<DefaultJavaAttributeMappingProvider> providers) {
-		providers.add(JavaEmbeddedMappingProvider.instance());  // bug 190344 need to test default embedded before basic
-		providers.add(JavaBasicMappingProvider.instance());
-	}
-
-	// ********** Mapping File **********
-
-	/**
-	 * Override this to specify more or different mapping file providers.
-	 */
+	
 	@Override
-	protected void addMappingFileProvidersTo(List<MappingFileProvider> providers) {
-		providers.add(GenericMappingFileProvider.instance());
+	protected JavaAttributeMappingProvider[] buildNonNullDefaultJavaAttributeMappingProviders() {
+		// order determined by analyzing order that reference implementation (toplink) uses
+		return new JavaAttributeMappingProvider[] {
+			JavaEmbeddedMappingProvider.instance(),
+			JavaBasicMappingProvider.instance()};
 	}
-
-
-	// ********** ORM type mappings **********
-
+	
 	@Override
-	protected void addOrmTypeMappingProvidersTo(List<OrmTypeMappingProvider> providers) {
-		providers.add(OrmEmbeddableProvider.instance());
-		providers.add(OrmEntityProvider.instance());
-		providers.add(OrmMappedSuperclassProvider.instance());
+	protected JavaAttributeMappingProvider[] buildNonNullSpecifiedJavaAttributeMappingProviders() {
+		// order determined by analyzing order that reference implementation (toplink) uses
+		return new JavaAttributeMappingProvider[] {
+			JavaTransientMappingProvider.instance(),
+			JavaIdMappingProvider.instance(),
+			JavaVersionMappingProvider.instance(),
+			JavaBasicMappingProvider.instance(),
+			JavaEmbeddedMappingProvider.instance(),
+			JavaEmbeddedIdMappingProvider.instance(),
+			JavaManyToManyMappingProvider.instance(),
+			JavaManyToOneMappingProvider.instance(),
+			JavaOneToManyMappingProvider.instance(),
+			JavaOneToOneMappingProvider.instance()};
 	}
-
-
-	// ********** ORM attribute mappings **********
-
+	
+	
+	// ********** Mapping Files **********
+	
 	@Override
-	protected void addOrmAttributeMappingProvidersTo(List<OrmAttributeMappingProvider> providers) {
-		providers.add(OrmEmbeddedMappingProvider.instance());  // bug 190344 need to test default embedded before basic
-		providers.add(OrmBasicMappingProvider.instance());
-		providers.add(OrmTransientMappingProvider.instance());
-		providers.add(OrmIdMappingProvider.instance());
-		providers.add(OrmManyToManyMappingProvider.instance());
-		providers.add(OrmOneToManyMappingProvider.instance());
-		providers.add(OrmManyToOneMappingProvider.instance());
-		providers.add(OrmOneToOneMappingProvider.instance());
-		providers.add(OrmVersionMappingProvider.instance());
-		providers.add(OrmEmbeddedIdMappingProvider.instance());
+	protected MappingFileDefinition[] buildMappingFileDefinitions() {
+		return new MappingFileDefinition[] {
+			GenericOrmMappingFileDefinition.instance()};
 	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/resource/orm/XmlAttributeMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/resource/orm/XmlAttributeMapping.java
index 568a076b72..7b70049969 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/resource/orm/XmlAttributeMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/resource/orm/XmlAttributeMapping.java
@@ -21,7 +21,9 @@ import org.eclipse.jpt.core.resource.orm.XmlAccessHolder;
  * @model kind="class" interface="true" abstract="true"
  * @generated
  */
-public interface XmlAttributeMapping extends org.eclipse.jpt.core.resource.orm.XmlAttributeMapping, XmlAccessHolder
+public interface XmlAttributeMapping
+	extends org.eclipse.jpt.core.resource.orm.XmlAttributeMapping, 
+			XmlAccessHolder
 {
 
 } // XmlAttributeMapping
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/AbstractXmlAttributeMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/AbstractXmlAttributeMapping.java
index c9d7cdb844..51fae884da 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/AbstractXmlAttributeMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/AbstractXmlAttributeMapping.java
@@ -32,7 +32,9 @@ import org.eclipse.wst.common.internal.emf.resource.Translator;
  * @model kind="class" abstract="true"
  * @generated
  */
-public abstract class AbstractXmlAttributeMapping extends AbstractJpaEObject implements XmlAttributeMapping
+public abstract class AbstractXmlAttributeMapping
+	extends AbstractJpaEObject
+	implements XmlAttributeMapping
 {
 	/**
 	 * The default value of the '{@link #getName() <em>Name</em>}' attribute.
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/OrmPackage.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/OrmPackage.java
index bf4d6479df..3a9589f165 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/OrmPackage.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/OrmPackage.java
@@ -5130,20 +5130,14 @@ public class OrmPackage extends EPackageImpl
 		XMLTypePackage.eINSTANCE.eClass();
 
 		// Obtain or create and register interdependencies
-		Orm2_0Package theOrm2_0Package = (Orm2_0Package)(EPackage.Registry.INSTANCE.getEPackage(Orm2_0Package.eNS_URI) instanceof Orm2_0Package ? EPackage.Registry.INSTANCE.getEPackage(Orm2_0Package.eNS_URI) : Orm2_0Package.eINSTANCE);
-		Persistence2_0Package thePersistence2_0Package = (Persistence2_0Package)(EPackage.Registry.INSTANCE.getEPackage(Persistence2_0Package.eNS_URI) instanceof Persistence2_0Package ? EPackage.Registry.INSTANCE.getEPackage(Persistence2_0Package.eNS_URI) : Persistence2_0Package.eINSTANCE);
 		PersistencePackage thePersistencePackage = (PersistencePackage)(EPackage.Registry.INSTANCE.getEPackage(PersistencePackage.eNS_URI) instanceof PersistencePackage ? EPackage.Registry.INSTANCE.getEPackage(PersistencePackage.eNS_URI) : PersistencePackage.eINSTANCE);
 
 		// Create package meta-data objects
 		theOrmPackage.createPackageContents();
-		theOrm2_0Package.createPackageContents();
-		thePersistence2_0Package.createPackageContents();
 		thePersistencePackage.createPackageContents();
 
 		// Initialize created meta-data
 		theOrmPackage.initializePackageContents();
-		theOrm2_0Package.initializePackageContents();
-		thePersistence2_0Package.initializePackageContents();
 		thePersistencePackage.initializePackageContents();
 
 		// Mark meta-data to indicate it can't be changed
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/EclipseLinkJpaPlatformFactory.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/EclipseLinkJpaPlatformFactory.java
index fba199f323..96f30dd518 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/EclipseLinkJpaPlatformFactory.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/EclipseLinkJpaPlatformFactory.java
@@ -10,14 +10,12 @@
 package org.eclipse.jpt.eclipselink.core.internal;
 
 import org.eclipse.jpt.core.JpaAnnotationProvider;
-import org.eclipse.jpt.core.JpaFactory;
 import org.eclipse.jpt.core.JpaPlatform;
 import org.eclipse.jpt.core.JpaPlatformFactory;
 import org.eclipse.jpt.core.JpaValidation;
 import org.eclipse.jpt.core.internal.platform.GenericJpaAnnotationDefinitionProvider;
 import org.eclipse.jpt.core.internal.platform.GenericJpaAnnotationProvider;
 import org.eclipse.jpt.core.internal.platform.GenericJpaPlatform;
-import org.eclipse.jpt.core.internal.platform.GenericJpaPlatformProvider;
 
 /**
  * All the state in the JPA platform should be "static" (i.e. unchanging once
@@ -37,17 +35,10 @@ public class EclipseLinkJpaPlatformFactory
 	public JpaPlatform buildJpaPlatform(String id) {
 		return new GenericJpaPlatform(
 			id,
-			buildJpaFactory(), 
+			new EclipseLinkJpaFactory(), 
 			buildJpaAnnotationProvider(), 
-			buildJpaValidation(),
 			EclipseLinkJpaPlatformProvider.instance(), 
-			//put eclipselink first because of the default java attribute mapping providers order,
-			//maybe there is a better way to handle that order dependency
-			GenericJpaPlatformProvider.instance());
-	}
-	
-	protected JpaFactory buildJpaFactory() {
-		return new EclipseLinkJpaFactory();
+			buildJpaValidation());
 	}
 	
 	protected JpaAnnotationProvider buildJpaAnnotationProvider() {
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/EclipseLinkJpaPlatformProvider.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/EclipseLinkJpaPlatformProvider.java
index 6fd0e66959..677f67f727 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/EclipseLinkJpaPlatformProvider.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/EclipseLinkJpaPlatformProvider.java
@@ -9,41 +9,35 @@
  *******************************************************************************/
 package org.eclipse.jpt.eclipselink.core.internal;
 
-import java.util.List;
 import org.eclipse.jpt.core.JpaPlatformProvider;
 import org.eclipse.jpt.core.JpaResourceModelProvider;
-import org.eclipse.jpt.core.context.MappingFileProvider;
-import org.eclipse.jpt.core.context.java.DefaultJavaAttributeMappingProvider;
+import org.eclipse.jpt.core.context.MappingFileDefinition;
 import org.eclipse.jpt.core.context.java.JavaAttributeMappingProvider;
 import org.eclipse.jpt.core.context.java.JavaTypeMappingProvider;
-import org.eclipse.jpt.core.context.orm.OrmAttributeMappingProvider;
-import org.eclipse.jpt.core.context.orm.OrmTypeMappingProvider;
+import org.eclipse.jpt.core.internal.JarResourceModelProvider;
+import org.eclipse.jpt.core.internal.JavaResourceModelProvider;
+import org.eclipse.jpt.core.internal.OrmResourceModelProvider;
+import org.eclipse.jpt.core.internal.PersistenceResourceModelProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaBasicMappingProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaEmbeddableProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaEmbeddedIdMappingProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaEmbeddedMappingProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaEntityProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaIdMappingProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaManyToManyMappingProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaManyToOneMappingProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaMappedSuperclassProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaTransientMappingProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaVersionMappingProvider;
+import org.eclipse.jpt.core.internal.context.orm.GenericOrmMappingFileDefinition;
 import org.eclipse.jpt.core.internal.platform.AbstractJpaPlatformProvider;
-import org.eclipse.jpt.eclipselink.core.internal.context.EclipseLinkMappingFileProvider;
-import org.eclipse.jpt.eclipselink.core.internal.context.java.JavaEclipseLinkOneToManyMappingProvider;
-import org.eclipse.jpt.eclipselink.core.internal.context.java.JavaEclipseLinkOneToOneMappingProvider;
+import org.eclipse.jpt.eclipselink.core.internal.context.EclipseLinkMappingFileDefinition;
 import org.eclipse.jpt.eclipselink.core.internal.context.java.JavaEclipseLinkBasicCollectionMappingProvider;
 import org.eclipse.jpt.eclipselink.core.internal.context.java.JavaEclipseLinkBasicMapMappingProvider;
+import org.eclipse.jpt.eclipselink.core.internal.context.java.JavaEclipseLinkOneToManyMappingProvider;
+import org.eclipse.jpt.eclipselink.core.internal.context.java.JavaEclipseLinkOneToOneMappingProvider;
 import org.eclipse.jpt.eclipselink.core.internal.context.java.JavaEclipseLinkTransformationMappingProvider;
 import org.eclipse.jpt.eclipselink.core.internal.context.java.JavaEclipseLinkVariableOneToOneMappingProvider;
-import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkBasicMappingProvider;
-import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkEmbeddableProvider;
-import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkEmbeddedIdMappingProvider;
-import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkEmbeddedMappingProvider;
-import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkEntityProvider;
-import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkIdMappingProvider;
-import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkManyToManyMappingProvider;
-import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkManyToOneMappingProvider;
-import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkMappedSuperclassProvider;
-import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkNullAttributeMappingProvider;
-import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkOneToManyMappingProvider;
-import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkOneToOneMappingProvider;
-import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkTransientMappingProvider;
-import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkVersionMappingProvider;
-import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkBasicCollectionMappingProvider;
-import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkBasicMapMappingProvider;
-import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkTransformationMappingProvider;
-import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkVariableOneToOneMappingProvider;
 
 /**
  * EclipseLink platform
@@ -51,90 +45,97 @@ import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkVaria
 public class EclipseLinkJpaPlatformProvider
 	extends AbstractJpaPlatformProvider
 {
-	
 	public static final String ID = "org.eclipse.eclipselink.platform"; //$NON-NLS-1$
 
 	// singleton
-	private static final JpaPlatformProvider INSTANCE = new EclipseLinkJpaPlatformProvider();
-
+	private static final JpaPlatformProvider INSTANCE = 
+			new EclipseLinkJpaPlatformProvider();
+	
+	
 	/**
 	 * Return the singleton.
 	 */
 	public static JpaPlatformProvider instance() {
 		return INSTANCE;
 	}
-
+	
+	
 	/**
-	 * Ensure single instance.
+	 * Enforce singleton usage
 	 */
 	private EclipseLinkJpaPlatformProvider() {
 		super();
 	}
-
 	
-	// ********* JPA files *********	
 	
-	@Override
-	protected void addResourceModelProvidersTo(List<JpaResourceModelProvider> providers) {
-		providers.add(EclipseLinkOrmResourceModelProvider.instance());
-	}
-
+	// ********* resource models *********	
 	
-	// ********* java *********	
-
 	@Override
-	protected void addJavaTypeMappingProvidersTo(List<JavaTypeMappingProvider> providers) {
-		//none specific to EclipseLink
-	}
-
-	@Override
-	protected void addJavaAttributeMappingProvidersTo(List<JavaAttributeMappingProvider> providers) {
-		providers.add(JavaEclipseLinkBasicCollectionMappingProvider.instance());
-		providers.add(JavaEclipseLinkBasicMapMappingProvider.instance());
-		providers.add(JavaEclipseLinkTransformationMappingProvider.instance());
-		providers.add(JavaEclipseLinkVariableOneToOneMappingProvider.instance());
+	protected JpaResourceModelProvider[] buildResourceModelProviders() {
+		// order should not be important here
+		return new JpaResourceModelProvider[] {
+			JavaResourceModelProvider.instance(),
+			JarResourceModelProvider.instance(),
+			PersistenceResourceModelProvider.instance(),
+			OrmResourceModelProvider.instance(),
+			EclipseLinkOrmResourceModelProvider.instance()};
 	}
 
+	
+	// ********* java type mappings *********	
+	
 	@Override
-	protected void addDefaultJavaAttributeMappingProvidersTo(List<DefaultJavaAttributeMappingProvider> providers) {
-		// these need to be checked first, so we can check for Basic last in case the reference object is Serializable
-		providers.add(JavaEclipseLinkOneToOneMappingProvider.instance());
-		providers.add(JavaEclipseLinkOneToManyMappingProvider.instance());
-		providers.add(JavaEclipseLinkVariableOneToOneMappingProvider.instance());
+	protected JavaTypeMappingProvider[] buildNonNullJavaTypeMappingProviders() {
+		// order determined by analyzing order that eclipselink uses
+		// NOTE: no type mappings specific to eclipselink
+		return new JavaTypeMappingProvider[] {
+			JavaEntityProvider.instance(),
+			JavaEmbeddableProvider.instance(),
+			JavaMappedSuperclassProvider.instance()};
 	}
 	
 	
-	// ********* ORM *********
+	// ********* java attribute mappings *********	
 	
 	@Override
-	protected void addOrmTypeMappingProvidersTo(List<OrmTypeMappingProvider> providers) {
-		providers.add(OrmEclipseLinkEmbeddableProvider.instance());
-		providers.add(OrmEclipseLinkEntityProvider.instance());
-		providers.add(OrmEclipseLinkMappedSuperclassProvider.instance());
+	protected JavaAttributeMappingProvider[] buildNonNullDefaultJavaAttributeMappingProviders() {
+		// order determined by analyzing order that eclipselink uses
+		return new JavaAttributeMappingProvider[] {
+			JavaEmbeddedMappingProvider.instance(),
+			JavaEclipseLinkOneToManyMappingProvider.instance(),
+			JavaEclipseLinkOneToOneMappingProvider.instance(),
+			JavaEclipseLinkVariableOneToOneMappingProvider.instance(),
+			JavaBasicMappingProvider.instance()};
 	}
 	
 	@Override
-	protected void addMappingFileProvidersTo(List<MappingFileProvider> providers) {
-		providers.add(EclipseLinkMappingFileProvider.instance());
+	protected JavaAttributeMappingProvider[] buildNonNullSpecifiedJavaAttributeMappingProviders() {
+		// order determined by analyzing order that eclipselink uses
+		return new JavaAttributeMappingProvider[] {
+			JavaTransientMappingProvider.instance(),
+			JavaEclipseLinkBasicCollectionMappingProvider.instance(),
+			JavaEclipseLinkBasicMapMappingProvider.instance(),
+			JavaIdMappingProvider.instance(),
+			JavaVersionMappingProvider.instance(),
+			JavaBasicMappingProvider.instance(),
+			JavaEmbeddedMappingProvider.instance(),
+			JavaEmbeddedIdMappingProvider.instance(),
+			JavaEclipseLinkTransformationMappingProvider.instance(),
+			JavaManyToManyMappingProvider.instance(),
+			JavaManyToOneMappingProvider.instance(),
+			JavaEclipseLinkOneToManyMappingProvider.instance(),
+			JavaEclipseLinkOneToOneMappingProvider.instance(),
+			JavaEclipseLinkVariableOneToOneMappingProvider.instance()};
 	}
-
+	
+	
+	// ********* mapping files *********	
+	
 	@Override
-	protected void addOrmAttributeMappingProvidersTo(List<OrmAttributeMappingProvider> providers) {
-		providers.add(OrmEclipseLinkBasicCollectionMappingProvider.instance());
-		providers.add(OrmEclipseLinkBasicMapMappingProvider.instance());
-		providers.add(OrmEclipseLinkTransformationMappingProvider.instance());
-		providers.add(OrmEclipseLinkVariableOneToOneMappingProvider.instance());
-		providers.add(OrmEclipseLinkBasicMappingProvider.instance());
-		providers.add(OrmEclipseLinkIdMappingProvider.instance());
-		providers.add(OrmEclipseLinkEmbeddedIdMappingProvider.instance());
-		providers.add(OrmEclipseLinkEmbeddedMappingProvider.instance());
-		providers.add(OrmEclipseLinkManyToManyMappingProvider.instance());
-		providers.add(OrmEclipseLinkManyToOneMappingProvider.instance());
-		providers.add(OrmEclipseLinkOneToManyMappingProvider.instance());
-		providers.add(OrmEclipseLinkOneToOneMappingProvider.instance());
-		providers.add(OrmEclipseLinkVersionMappingProvider.instance());
-		providers.add(OrmEclipseLinkTransientMappingProvider.instance());
-		providers.add(OrmEclipseLinkNullAttributeMappingProvider.instance());
+	protected MappingFileDefinition[] buildMappingFileDefinitions() {
+		// order should not be important here
+		return new MappingFileDefinition[] {
+			EclipseLinkMappingFileDefinition.instance(),
+			GenericOrmMappingFileDefinition.instance()};
 	}
-
 }
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/EclipseLinkMappingFileDefinition.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/EclipseLinkMappingFileDefinition.java
new file mode 100644
index 0000000000..214c7ffa90
--- /dev/null
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/EclipseLinkMappingFileDefinition.java
@@ -0,0 +1,108 @@
+/*******************************************************************************
+ * Copyright (c) 2008, 2009 Oracle. All rights reserved.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0, which accompanies this distribution
+ * and is available at http://www.eclipse.org/legal/epl-v10.html.
+ * 
+ * Contributors:
+ *     Oracle - initial API and implementation
+ ******************************************************************************/
+package org.eclipse.jpt.eclipselink.core.internal.context;
+
+import org.eclipse.core.runtime.content.IContentType;
+import org.eclipse.jpt.core.JpaFactory;
+import org.eclipse.jpt.core.context.MappingFile;
+import org.eclipse.jpt.core.context.MappingFileDefinition;
+import org.eclipse.jpt.core.context.orm.OrmAttributeMappingProvider;
+import org.eclipse.jpt.core.context.orm.OrmTypeMappingProvider;
+import org.eclipse.jpt.core.context.persistence.MappingFileRef;
+import org.eclipse.jpt.core.internal.platform.AbstractMappingFileDefinition;
+import org.eclipse.jpt.core.resource.xml.JpaXmlResource;
+import org.eclipse.jpt.eclipselink.core.internal.EclipseLinkJpaFactory;
+import org.eclipse.jpt.eclipselink.core.internal.JptEclipseLinkCorePlugin;
+import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkBasicCollectionMappingProvider;
+import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkBasicMapMappingProvider;
+import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkBasicMappingProvider;
+import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkEmbeddableProvider;
+import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkEmbeddedIdMappingProvider;
+import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkEmbeddedMappingProvider;
+import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkEntityProvider;
+import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkIdMappingProvider;
+import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkManyToManyMappingProvider;
+import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkManyToOneMappingProvider;
+import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkMappedSuperclassProvider;
+import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkNullAttributeMappingProvider;
+import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkOneToManyMappingProvider;
+import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkOneToOneMappingProvider;
+import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkTransformationMappingProvider;
+import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkTransientMappingProvider;
+import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkVariableOneToOneMappingProvider;
+import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkVersionMappingProvider;
+
+public class EclipseLinkMappingFileDefinition
+	extends AbstractMappingFileDefinition
+{
+	// singleton
+	private static final MappingFileDefinition INSTANCE = 
+			new EclipseLinkMappingFileDefinition();
+
+	/**
+	 * Return the singleton.
+	 */
+	public static MappingFileDefinition instance() {
+		return INSTANCE;
+	}
+
+	/**
+	 * Ensure single instance.
+	 */
+	private EclipseLinkMappingFileDefinition() {
+		super();
+	}
+
+	public IContentType getContentType() {
+		return JptEclipseLinkCorePlugin.ECLIPSELINK_ORM_XML_CONTENT_TYPE;
+	}
+
+	public MappingFile buildMappingFile(MappingFileRef parent, JpaXmlResource resource, JpaFactory factory) {
+		return ((EclipseLinkJpaFactory) factory).buildEclipseLinkMappingFile(parent, resource);
+	}
+	
+	
+	// ********* ORM type mappings *********
+	
+	@Override
+	protected OrmTypeMappingProvider[] buildOrmTypeMappingProviders() {
+		// order should not matter here, but we'll use the same order as for java
+		// @see {@link EclipseLinkJpaPlatformProvider}
+		return new OrmTypeMappingProvider[] {
+			OrmEclipseLinkEntityProvider.instance(),
+			OrmEclipseLinkEmbeddableProvider.instance(),
+			OrmEclipseLinkMappedSuperclassProvider.instance()};
+	}
+	
+	
+	// ********** ORM attribute mappings **********
+	
+	@Override
+	protected OrmAttributeMappingProvider[] buildOrmAttributeMappingProviders() {
+		// order should not matter here, but we'll use the same order as for java
+		// @see {@link EclipseLinkJpaPlatformProvider}
+		return new OrmAttributeMappingProvider[] {
+			OrmEclipseLinkTransientMappingProvider.instance(),
+			OrmEclipseLinkBasicCollectionMappingProvider.instance(),
+			OrmEclipseLinkBasicMapMappingProvider.instance(),
+			OrmEclipseLinkIdMappingProvider.instance(),
+			OrmEclipseLinkVersionMappingProvider.instance(),
+			OrmEclipseLinkBasicMappingProvider.instance(),
+			OrmEclipseLinkEmbeddedMappingProvider.instance(),
+			OrmEclipseLinkEmbeddedIdMappingProvider.instance(),
+			OrmEclipseLinkTransformationMappingProvider.instance(),
+			OrmEclipseLinkManyToManyMappingProvider.instance(),
+			OrmEclipseLinkManyToOneMappingProvider.instance(),
+			OrmEclipseLinkOneToManyMappingProvider.instance(),
+			OrmEclipseLinkOneToOneMappingProvider.instance(),
+			OrmEclipseLinkVariableOneToOneMappingProvider.instance(),
+			OrmEclipseLinkNullAttributeMappingProvider.instance()};
+	}
+}
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/EclipseLinkMappingFileProvider.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/EclipseLinkMappingFileProvider.java
deleted file mode 100644
index a278471e45..0000000000
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/EclipseLinkMappingFileProvider.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2008, 2009 Oracle. All rights reserved.
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0, which accompanies this distribution
- * and is available at http://www.eclipse.org/legal/epl-v10.html.
- * 
- * Contributors:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.eclipselink.core.internal.context;
-
-import org.eclipse.core.runtime.content.IContentType;
-import org.eclipse.jpt.core.JpaFactory;
-import org.eclipse.jpt.core.context.MappingFile;
-import org.eclipse.jpt.core.context.MappingFileProvider;
-import org.eclipse.jpt.core.context.persistence.MappingFileRef;
-import org.eclipse.jpt.core.resource.xml.JpaXmlResource;
-import org.eclipse.jpt.eclipselink.core.internal.EclipseLinkJpaFactory;
-import org.eclipse.jpt.eclipselink.core.internal.JptEclipseLinkCorePlugin;
-
-public class EclipseLinkMappingFileProvider
-	implements MappingFileProvider
-{
-	// singleton
-	private static final MappingFileProvider INSTANCE = new EclipseLinkMappingFileProvider();
-
-	/**
-	 * Return the singleton.
-	 */
-	public static MappingFileProvider instance() {
-		return INSTANCE;
-	}
-
-	/**
-	 * Ensure single instance.
-	 */
-	private EclipseLinkMappingFileProvider() {
-		super();
-	}
-
-	public IContentType getContentType() {
-		return JptEclipseLinkCorePlugin.ECLIPSELINK_ORM_XML_CONTENT_TYPE;
-	}
-
-	public MappingFile buildMappingFile(MappingFileRef parent, JpaXmlResource resource, JpaFactory factory) {
-		return ((EclipseLinkJpaFactory) factory).buildEclipseLinkMappingFile(parent, resource);
-	}
-
-}
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/JavaEclipseLinkBasicCollectionMappingProvider.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/JavaEclipseLinkBasicCollectionMappingProvider.java
index c024eb900b..6c5840e787 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/JavaEclipseLinkBasicCollectionMappingProvider.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/JavaEclipseLinkBasicCollectionMappingProvider.java
@@ -13,31 +13,35 @@ import org.eclipse.jpt.core.JpaFactory;
 import org.eclipse.jpt.core.context.java.JavaAttributeMapping;
 import org.eclipse.jpt.core.context.java.JavaAttributeMappingProvider;
 import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;
+import org.eclipse.jpt.core.internal.context.java.AbstractJavaAttributeMappingProvider;
 import org.eclipse.jpt.eclipselink.core.EclipseLinkMappingKeys;
 import org.eclipse.jpt.eclipselink.core.internal.EclipseLinkJpaFactory;
 import org.eclipse.jpt.eclipselink.core.resource.java.EclipseLinkBasicCollectionAnnotation;
 
 public class JavaEclipseLinkBasicCollectionMappingProvider
-	implements JavaAttributeMappingProvider
+	extends AbstractJavaAttributeMappingProvider
 {
-
 	// singleton
-	private static final JavaEclipseLinkBasicCollectionMappingProvider INSTANCE = new JavaEclipseLinkBasicCollectionMappingProvider();
-
+	private static final JavaEclipseLinkBasicCollectionMappingProvider INSTANCE = 
+			new JavaEclipseLinkBasicCollectionMappingProvider();
+	
+	
 	/**
 	 * Return the singleton.
 	 */
 	public static JavaAttributeMappingProvider instance() {
 		return INSTANCE;
 	}
-
+	
+	
 	/**
-	 * Ensure single instance.
+	 * Enforce singleton usage
 	 */
 	private JavaEclipseLinkBasicCollectionMappingProvider() {
 		super();
 	}
-
+	
+	
 	public String getKey() {
 		return EclipseLinkMappingKeys.BASIC_COLLECTION_ATTRIBUTE_MAPPING_KEY;
 	}
@@ -45,7 +49,7 @@ public class JavaEclipseLinkBasicCollectionMappingProvider
 	public String getAnnotationName() {
 		return EclipseLinkBasicCollectionAnnotation.ANNOTATION_NAME;
 	}
-
+	
 	public JavaAttributeMapping buildMapping(JavaPersistentAttribute parent, JpaFactory factory) {
 		return ((EclipseLinkJpaFactory) factory).buildJavaEclipseLinkBasicCollectionMapping(parent);
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/JavaEclipseLinkBasicMapMappingProvider.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/JavaEclipseLinkBasicMapMappingProvider.java
index 99010f2541..3d52b1141b 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/JavaEclipseLinkBasicMapMappingProvider.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/JavaEclipseLinkBasicMapMappingProvider.java
@@ -13,31 +13,35 @@ import org.eclipse.jpt.core.JpaFactory;
 import org.eclipse.jpt.core.context.java.JavaAttributeMapping;
 import org.eclipse.jpt.core.context.java.JavaAttributeMappingProvider;
 import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;
+import org.eclipse.jpt.core.internal.context.java.AbstractJavaAttributeMappingProvider;
 import org.eclipse.jpt.eclipselink.core.EclipseLinkMappingKeys;
 import org.eclipse.jpt.eclipselink.core.internal.EclipseLinkJpaFactory;
 import org.eclipse.jpt.eclipselink.core.resource.java.EclipseLinkBasicMapAnnotation;
 
 public class JavaEclipseLinkBasicMapMappingProvider
-	implements JavaAttributeMappingProvider
+	extends AbstractJavaAttributeMappingProvider
 {
-
 	// singleton
-	private static final JavaEclipseLinkBasicMapMappingProvider INSTANCE = new JavaEclipseLinkBasicMapMappingProvider();
-
+	private static final JavaEclipseLinkBasicMapMappingProvider INSTANCE = 
+			new JavaEclipseLinkBasicMapMappingProvider();
+	
+	
 	/**
 	 * Return the singleton.
 	 */
 	public static JavaAttributeMappingProvider instance() {
 		return INSTANCE;
 	}
-
+	
+	
 	/**
-	 * Ensure single instance.
+	 * Enforce singleton usage
 	 */
 	private JavaEclipseLinkBasicMapMappingProvider() {
 		super();
 	}
-
+	
+	
 	public String getKey() {
 		return EclipseLinkMappingKeys.BASIC_MAP_ATTRIBUTE_MAPPING_KEY;
 	}
@@ -45,7 +49,7 @@ public class JavaEclipseLinkBasicMapMappingProvider
 	public String getAnnotationName() {
 		return EclipseLinkBasicMapAnnotation.ANNOTATION_NAME;
 	}
-
+	
 	public JavaAttributeMapping buildMapping(JavaPersistentAttribute parent, JpaFactory factory) {
 		return ((EclipseLinkJpaFactory) factory).buildJavaEclipseLinkBasicMapMapping(parent);
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/JavaEclipseLinkOneToManyMappingProvider.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/JavaEclipseLinkOneToManyMappingProvider.java
index ad72c97e73..af08f01cab 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/JavaEclipseLinkOneToManyMappingProvider.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/JavaEclipseLinkOneToManyMappingProvider.java
@@ -10,32 +10,36 @@
 package org.eclipse.jpt.eclipselink.core.internal.context.java;
 
 import org.eclipse.jpt.core.JpaFactory;
-import org.eclipse.jpt.core.context.java.DefaultJavaAttributeMappingProvider;
 import org.eclipse.jpt.core.context.java.JavaAttributeMapping;
+import org.eclipse.jpt.core.context.java.JavaAttributeMappingProvider;
 import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;
+import org.eclipse.jpt.core.internal.context.java.AbstractJavaAttributeMappingProvider;
 import org.eclipse.jpt.core.internal.context.java.JavaOneToManyMappingProvider;
 
 public class JavaEclipseLinkOneToManyMappingProvider
-	implements DefaultJavaAttributeMappingProvider
+	extends AbstractJavaAttributeMappingProvider
 {
-
 	// singleton
-	private static final JavaEclipseLinkOneToManyMappingProvider INSTANCE = new JavaEclipseLinkOneToManyMappingProvider();
-
+	private static final JavaEclipseLinkOneToManyMappingProvider INSTANCE = 
+			new JavaEclipseLinkOneToManyMappingProvider();
+	
+	
 	/**
 	 * Return the singleton.
 	 */
-	public static DefaultJavaAttributeMappingProvider instance() {
+	public static JavaAttributeMappingProvider instance() {
 		return INSTANCE;
 	}
-
+	
+	
 	/**
-	 * Ensure single instance.
+	 * Enforce singleton usage
 	 */
 	private JavaEclipseLinkOneToManyMappingProvider() {
 		super();
 	}
-
+	
+	
 	public String getKey() {
 		return JavaOneToManyMappingProvider.instance().getKey();
 	}
@@ -48,6 +52,7 @@ public class JavaEclipseLinkOneToManyMappingProvider
 		return JavaOneToManyMappingProvider.instance().buildMapping(parent, factory);
 	}
 	
+	@Override
 	public boolean defaultApplies(JavaPersistentAttribute persistentAttribute) {
 		String targetEntity = persistentAttribute.getMultiReferenceEntityTypeName();
 		return (targetEntity != null) 
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/JavaEclipseLinkOneToOneMappingProvider.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/JavaEclipseLinkOneToOneMappingProvider.java
index 6761b9cf33..9ab909556f 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/JavaEclipseLinkOneToOneMappingProvider.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/JavaEclipseLinkOneToOneMappingProvider.java
@@ -10,32 +10,36 @@
 package org.eclipse.jpt.eclipselink.core.internal.context.java;
 
 import org.eclipse.jpt.core.JpaFactory;
-import org.eclipse.jpt.core.context.java.DefaultJavaAttributeMappingProvider;
 import org.eclipse.jpt.core.context.java.JavaAttributeMapping;
+import org.eclipse.jpt.core.context.java.JavaAttributeMappingProvider;
 import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;
+import org.eclipse.jpt.core.internal.context.java.AbstractJavaAttributeMappingProvider;
 import org.eclipse.jpt.core.internal.context.java.JavaOneToOneMappingProvider;
 
 public class JavaEclipseLinkOneToOneMappingProvider
-	implements DefaultJavaAttributeMappingProvider
+	extends AbstractJavaAttributeMappingProvider
 {
-
 	// singleton
-	private static final JavaEclipseLinkOneToOneMappingProvider INSTANCE = new JavaEclipseLinkOneToOneMappingProvider();
-
+	private static final JavaEclipseLinkOneToOneMappingProvider INSTANCE = 
+			new JavaEclipseLinkOneToOneMappingProvider();
+	
+	
 	/**
 	 * Return the singleton.
 	 */
-	public static DefaultJavaAttributeMappingProvider instance() {
+	public static JavaAttributeMappingProvider instance() {
 		return INSTANCE;
 	}
-
+	
+	
 	/**
-	 * Ensure single instance.
+	 * Enforce singleton usage
 	 */
 	private JavaEclipseLinkOneToOneMappingProvider() {
 		super();
 	}
-
+	
+	
 	public String getKey() {
 		return JavaOneToOneMappingProvider.instance().getKey();
 	}
@@ -43,11 +47,12 @@ public class JavaEclipseLinkOneToOneMappingProvider
 	public String getAnnotationName() {
 		return JavaOneToOneMappingProvider.instance().getAnnotationName();
 	}
-
+	
 	public JavaAttributeMapping buildMapping(JavaPersistentAttribute parent, JpaFactory factory) {
 		return JavaOneToOneMappingProvider.instance().buildMapping(parent, factory);
 	}
 	
+	@Override
 	public boolean defaultApplies(JavaPersistentAttribute persistentAttribute) {
 		String targetEntity = persistentAttribute.getSingleReferenceEntityTypeName();
 		return (targetEntity != null)
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/JavaEclipseLinkTransformationMappingProvider.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/JavaEclipseLinkTransformationMappingProvider.java
index a51acf2c8f..1b50c0088c 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/JavaEclipseLinkTransformationMappingProvider.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/JavaEclipseLinkTransformationMappingProvider.java
@@ -13,31 +13,35 @@ import org.eclipse.jpt.core.JpaFactory;
 import org.eclipse.jpt.core.context.java.JavaAttributeMapping;
 import org.eclipse.jpt.core.context.java.JavaAttributeMappingProvider;
 import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;
+import org.eclipse.jpt.core.internal.context.java.AbstractJavaAttributeMappingProvider;
 import org.eclipse.jpt.eclipselink.core.EclipseLinkMappingKeys;
 import org.eclipse.jpt.eclipselink.core.internal.EclipseLinkJpaFactory;
 import org.eclipse.jpt.eclipselink.core.resource.java.EclipseLinkTransformationAnnotation;
 
 public class JavaEclipseLinkTransformationMappingProvider
-	implements JavaAttributeMappingProvider
+	extends AbstractJavaAttributeMappingProvider
 {
-
 	// singleton
-	private static final JavaEclipseLinkTransformationMappingProvider INSTANCE = new JavaEclipseLinkTransformationMappingProvider();
-
+	private static final JavaEclipseLinkTransformationMappingProvider INSTANCE = 
+			new JavaEclipseLinkTransformationMappingProvider();
+	
+	
 	/**
 	 * Return the singleton.
 	 */
 	public static JavaAttributeMappingProvider instance() {
 		return INSTANCE;
 	}
-
+	
+	
 	/**
-	 * Ensure single instance.
+	 * Enforce singleton usage
 	 */
 	private JavaEclipseLinkTransformationMappingProvider() {
 		super();
 	}
-
+	
+	
 	public String getKey() {
 		return EclipseLinkMappingKeys.TRANSFORMATION_ATTRIBUTE_MAPPING_KEY;
 	}
@@ -45,7 +49,7 @@ public class JavaEclipseLinkTransformationMappingProvider
 	public String getAnnotationName() {
 		return EclipseLinkTransformationAnnotation.ANNOTATION_NAME;
 	}
-
+	
 	public JavaAttributeMapping buildMapping(JavaPersistentAttribute parent, JpaFactory factory) {
 		return ((EclipseLinkJpaFactory) factory).buildJavaEclipseLinkTransformationMapping(parent);
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/JavaEclipseLinkVariableOneToOneMappingProvider.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/JavaEclipseLinkVariableOneToOneMappingProvider.java
index 084c99c8b5..efeb4a0d12 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/JavaEclipseLinkVariableOneToOneMappingProvider.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/JavaEclipseLinkVariableOneToOneMappingProvider.java
@@ -10,34 +10,38 @@
 package org.eclipse.jpt.eclipselink.core.internal.context.java;
 
 import org.eclipse.jpt.core.JpaFactory;
-import org.eclipse.jpt.core.context.java.DefaultJavaAttributeMappingProvider;
 import org.eclipse.jpt.core.context.java.JavaAttributeMapping;
+import org.eclipse.jpt.core.context.java.JavaAttributeMappingProvider;
 import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;
+import org.eclipse.jpt.core.internal.context.java.AbstractJavaAttributeMappingProvider;
 import org.eclipse.jpt.eclipselink.core.EclipseLinkMappingKeys;
 import org.eclipse.jpt.eclipselink.core.internal.EclipseLinkJpaFactory;
 import org.eclipse.jpt.eclipselink.core.resource.java.EclipseLinkVariableOneToOneAnnotation;
 
 public class JavaEclipseLinkVariableOneToOneMappingProvider
-	implements DefaultJavaAttributeMappingProvider
+	extends AbstractJavaAttributeMappingProvider
 {
-
 	// singleton
-	private static final JavaEclipseLinkVariableOneToOneMappingProvider INSTANCE = new JavaEclipseLinkVariableOneToOneMappingProvider();
-
+	private static final JavaEclipseLinkVariableOneToOneMappingProvider INSTANCE = 
+			new JavaEclipseLinkVariableOneToOneMappingProvider();
+	
+	
 	/**
 	 * Return the singleton.
 	 */
-	public static DefaultJavaAttributeMappingProvider instance() {
+	public static JavaAttributeMappingProvider instance() {
 		return INSTANCE;
 	}
-
+	
+	
 	/**
-	 * Ensure single instance.
+	 * Enforce singleton usage
 	 */
 	private JavaEclipseLinkVariableOneToOneMappingProvider() {
 		super();
 	}
-
+	
+	
 	public String getKey() {
 		return EclipseLinkMappingKeys.VARIABLE_ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY;
 	}
@@ -45,11 +49,12 @@ public class JavaEclipseLinkVariableOneToOneMappingProvider
 	public String getAnnotationName() {
 		return EclipseLinkVariableOneToOneAnnotation.ANNOTATION_NAME;
 	}
-
+	
 	public JavaAttributeMapping buildMapping(JavaPersistentAttribute parent, JpaFactory factory) {
 		return ((EclipseLinkJpaFactory) factory).buildJavaEclipseLinkVariableOneToOneMapping(parent);
 	}
 	
+	@Override
 	public boolean defaultApplies(JavaPersistentAttribute persistentAttribute) {
 		return ((JavaEclipseLinkPersistentAttribute) persistentAttribute).typeIsValidForVariableOneToOne();
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v1_1/EclipseLink1_1JpaPlatformFactory.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v1_1/EclipseLink1_1JpaPlatformFactory.java
index a3f6ceea21..1e62f2eac6 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v1_1/EclipseLink1_1JpaPlatformFactory.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v1_1/EclipseLink1_1JpaPlatformFactory.java
@@ -10,16 +10,13 @@
 package org.eclipse.jpt.eclipselink.core.internal.v1_1;
 
 import org.eclipse.jpt.core.JpaAnnotationProvider;
-import org.eclipse.jpt.core.JpaFactory;
 import org.eclipse.jpt.core.JpaPlatform;
 import org.eclipse.jpt.core.JpaPlatformFactory;
 import org.eclipse.jpt.core.JpaValidation;
 import org.eclipse.jpt.core.internal.platform.GenericJpaAnnotationDefinitionProvider;
 import org.eclipse.jpt.core.internal.platform.GenericJpaAnnotationProvider;
 import org.eclipse.jpt.core.internal.platform.GenericJpaPlatform;
-import org.eclipse.jpt.core.internal.platform.GenericJpaPlatformProvider;
 import org.eclipse.jpt.eclipselink.core.internal.EclipseLinkJpaAnnotationDefinitionProvider;
-import org.eclipse.jpt.eclipselink.core.internal.EclipseLinkJpaPlatformProvider;
 
 /**
  * All the state in the JPA platform should be "static" (i.e. unchanging once
@@ -28,7 +25,6 @@ import org.eclipse.jpt.eclipselink.core.internal.EclipseLinkJpaPlatformProvider;
 public class EclipseLink1_1JpaPlatformFactory
 	implements JpaPlatformFactory
 {
-
 	/**
 	 * zero-argument constructor
 	 */
@@ -36,21 +32,14 @@ public class EclipseLink1_1JpaPlatformFactory
 		super();
 	}
 	
+	
 	public JpaPlatform buildJpaPlatform(String id) {
 		return new GenericJpaPlatform(
 			id,
-			buildJpaFactory(), 
-			buildJpaAnnotationProvider(), 
-			buildJpaValidation(),
-			EclipseLinkJpaPlatformProvider.instance(), 
-			//put eclipselink first because of the default java attribute mapping providers order,
-			//maybe there is a better way to handle that order dependency
-			GenericJpaPlatformProvider.instance(),
-			EclipseLink1_1JpaPlatformProvider.instance());
-	}
-	
-	protected JpaFactory buildJpaFactory() {
-		return new EclipseLink1_1JpaFactory();
+			new EclipseLink1_1JpaFactory(), 
+			buildJpaAnnotationProvider(),
+			EclipseLink1_1JpaPlatformProvider.instance(), 
+			buildJpaValidation());
 	}
 	
 	protected JpaAnnotationProvider buildJpaAnnotationProvider() {
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v1_1/EclipseLink1_1JpaPlatformProvider.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v1_1/EclipseLink1_1JpaPlatformProvider.java
index f10caceb72..7ea997e71e 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v1_1/EclipseLink1_1JpaPlatformProvider.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v1_1/EclipseLink1_1JpaPlatformProvider.java
@@ -9,32 +9,37 @@
  *******************************************************************************/
 package org.eclipse.jpt.eclipselink.core.internal.v1_1;
 
-import java.util.List;
 import org.eclipse.jpt.core.JpaPlatformProvider;
 import org.eclipse.jpt.core.JpaResourceModelProvider;
-import org.eclipse.jpt.core.context.MappingFileProvider;
-import org.eclipse.jpt.core.context.java.DefaultJavaAttributeMappingProvider;
+import org.eclipse.jpt.core.context.MappingFileDefinition;
 import org.eclipse.jpt.core.context.java.JavaAttributeMappingProvider;
 import org.eclipse.jpt.core.context.java.JavaTypeMappingProvider;
-import org.eclipse.jpt.core.context.orm.OrmAttributeMappingProvider;
-import org.eclipse.jpt.core.context.orm.OrmTypeMappingProvider;
+import org.eclipse.jpt.core.internal.JarResourceModelProvider;
+import org.eclipse.jpt.core.internal.JavaResourceModelProvider;
+import org.eclipse.jpt.core.internal.OrmResourceModelProvider;
+import org.eclipse.jpt.core.internal.PersistenceResourceModelProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaBasicMappingProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaEmbeddableProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaEmbeddedIdMappingProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaEmbeddedMappingProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaEntityProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaIdMappingProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaManyToManyMappingProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaManyToOneMappingProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaMappedSuperclassProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaTransientMappingProvider;
+import org.eclipse.jpt.core.internal.context.java.JavaVersionMappingProvider;
+import org.eclipse.jpt.core.internal.context.orm.GenericOrmMappingFileDefinition;
 import org.eclipse.jpt.core.internal.platform.AbstractJpaPlatformProvider;
-import org.eclipse.jpt.eclipselink.core.internal.v1_1.context.EclipseLinkMappingFile1_1Provider;
-import org.eclipse.jpt.eclipselink.core.internal.v1_1.context.orm.OrmEclipseLinkBasicCollectionMapping1_1Provider;
-import org.eclipse.jpt.eclipselink.core.internal.v1_1.context.orm.OrmEclipseLinkBasicMapMapping1_1Provider;
-import org.eclipse.jpt.eclipselink.core.internal.v1_1.context.orm.OrmEclipseLinkBasicMapping1_1Provider;
-import org.eclipse.jpt.eclipselink.core.internal.v1_1.context.orm.OrmEclipseLinkEmbeddedIdMapping1_1Provider;
-import org.eclipse.jpt.eclipselink.core.internal.v1_1.context.orm.OrmEclipseLinkEmbeddedMapping1_1Provider;
-import org.eclipse.jpt.eclipselink.core.internal.v1_1.context.orm.OrmEclipseLinkIdMapping1_1Provider;
-import org.eclipse.jpt.eclipselink.core.internal.v1_1.context.orm.OrmEclipseLinkManyToManyMapping1_1Provider;
-import org.eclipse.jpt.eclipselink.core.internal.v1_1.context.orm.OrmEclipseLinkManyToOneMapping1_1Provider;
-import org.eclipse.jpt.eclipselink.core.internal.v1_1.context.orm.OrmEclipseLinkNullAttributeMapping1_1Provider;
-import org.eclipse.jpt.eclipselink.core.internal.v1_1.context.orm.OrmEclipseLinkOneToManyMapping1_1Provider;
-import org.eclipse.jpt.eclipselink.core.internal.v1_1.context.orm.OrmEclipseLinkOneToOneMapping1_1Provider;
-import org.eclipse.jpt.eclipselink.core.internal.v1_1.context.orm.OrmEclipseLinkTransformationMapping1_1Provider;
-import org.eclipse.jpt.eclipselink.core.internal.v1_1.context.orm.OrmEclipseLinkTransientMapping1_1Provider;
-import org.eclipse.jpt.eclipselink.core.internal.v1_1.context.orm.OrmEclipseLinkVariableOneToOneMapping1_1Provider;
-import org.eclipse.jpt.eclipselink.core.internal.v1_1.context.orm.OrmEclipseLinkVersionMapping1_1Provider;
+import org.eclipse.jpt.eclipselink.core.internal.EclipseLinkOrmResourceModelProvider;
+import org.eclipse.jpt.eclipselink.core.internal.context.EclipseLinkMappingFileDefinition;
+import org.eclipse.jpt.eclipselink.core.internal.context.java.JavaEclipseLinkBasicCollectionMappingProvider;
+import org.eclipse.jpt.eclipselink.core.internal.context.java.JavaEclipseLinkBasicMapMappingProvider;
+import org.eclipse.jpt.eclipselink.core.internal.context.java.JavaEclipseLinkOneToManyMappingProvider;
+import org.eclipse.jpt.eclipselink.core.internal.context.java.JavaEclipseLinkOneToOneMappingProvider;
+import org.eclipse.jpt.eclipselink.core.internal.context.java.JavaEclipseLinkTransformationMappingProvider;
+import org.eclipse.jpt.eclipselink.core.internal.context.java.JavaEclipseLinkVariableOneToOneMappingProvider;
+import org.eclipse.jpt.eclipselink.core.internal.v1_1.context.EclipseLink1_1MappingFileDefinition;
 
 /**
  * EclipseLink platform
@@ -45,79 +50,98 @@ public class EclipseLink1_1JpaPlatformProvider
 	public static final String ID = "eclipselink1_1"; //$NON-NLS-1$
 
 	// singleton
-	private static final JpaPlatformProvider INSTANCE = new EclipseLink1_1JpaPlatformProvider();
-
+	private static final JpaPlatformProvider INSTANCE = 
+			new EclipseLink1_1JpaPlatformProvider();
+	
+	
 	/**
 	 * Return the singleton.
 	 */
 	public static JpaPlatformProvider instance() {
 		return INSTANCE;
 	}
-
+	
+	
 	/**
-	 * Ensure single instance.
+	 * Enforce singleton usage
 	 */
 	private EclipseLink1_1JpaPlatformProvider() {
 		super();
 	}
-
 	
-	// ********* JPA files *********	
 	
-	@Override
-	protected void addResourceModelProvidersTo(List<JpaResourceModelProvider> providers) {
-		providers.add(EclipseLink1_1OrmResourceModelProvider.instance());
-	}
-
+	// ********** resource models **********
 	
-	// ********* java *********	
-
 	@Override
-	protected void addJavaTypeMappingProvidersTo(List<JavaTypeMappingProvider> providers) {
-		//none specific to EclipseLink1.1
-	}
-
-	@Override
-	protected void addJavaAttributeMappingProvidersTo(List<JavaAttributeMappingProvider> providers) {
-		//none specific to EclipseLink1.1
+	protected JpaResourceModelProvider[] buildResourceModelProviders() {
+		// order should not be important here
+		return new JpaResourceModelProvider[] {
+			JavaResourceModelProvider.instance(),
+			JarResourceModelProvider.instance(),
+			PersistenceResourceModelProvider.instance(),
+			OrmResourceModelProvider.instance(),
+			EclipseLinkOrmResourceModelProvider.instance(),
+			EclipseLink1_1OrmResourceModelProvider.instance()};
 	}
 
+	
+	// ********* java type mappings *********	
+	
 	@Override
-	protected void addDefaultJavaAttributeMappingProvidersTo(List<DefaultJavaAttributeMappingProvider> providers) {
-		//none specific to EclipseLink1.1
+	protected JavaTypeMappingProvider[] buildNonNullJavaTypeMappingProviders() {
+		// order determined by analyzing order that eclipselink uses
+		// NOTE: no type mappings specific to eclipselink
+		return new JavaTypeMappingProvider[] {
+			JavaEntityProvider.instance(),
+			JavaEmbeddableProvider.instance(),
+			JavaMappedSuperclassProvider.instance()};
 	}
 	
 	
-	// ********* ORM *********
+	// ********* java attribute mappings *********	
 	
 	@Override
-	protected void addOrmTypeMappingProvidersTo(List<OrmTypeMappingProvider> providers) {
-		//none specific to EclipseLink 1.1
+	protected JavaAttributeMappingProvider[] buildNonNullDefaultJavaAttributeMappingProviders() {
+		// order determined by analyzing order that eclipselink uses
+		// NOTE: no new attribute mappings from eclipselink 1.0 to 1.1
+		return new JavaAttributeMappingProvider[] {
+			JavaEmbeddedMappingProvider.instance(),
+			JavaEclipseLinkOneToManyMappingProvider.instance(),
+			JavaEclipseLinkOneToOneMappingProvider.instance(),
+			JavaEclipseLinkVariableOneToOneMappingProvider.instance(),
+			JavaBasicMappingProvider.instance()};
 	}
 	
 	@Override
-	protected void addMappingFileProvidersTo(List<MappingFileProvider> providers) {
-		providers.add(EclipseLinkMappingFile1_1Provider.instance());
+	protected JavaAttributeMappingProvider[] buildNonNullSpecifiedJavaAttributeMappingProviders() {
+		// order determined by analyzing order that eclipselink uses
+		// NOTE: no new attribute mappings from eclipselink 1.0 to 1.1
+		return new JavaAttributeMappingProvider[] {
+			JavaTransientMappingProvider.instance(),
+			JavaEclipseLinkBasicCollectionMappingProvider.instance(),
+			JavaEclipseLinkBasicMapMappingProvider.instance(),
+			JavaIdMappingProvider.instance(),
+			JavaVersionMappingProvider.instance(),
+			JavaBasicMappingProvider.instance(),
+			JavaEmbeddedMappingProvider.instance(),
+			JavaEmbeddedIdMappingProvider.instance(),
+			JavaEclipseLinkTransformationMappingProvider.instance(),
+			JavaManyToManyMappingProvider.instance(),
+			JavaManyToOneMappingProvider.instance(),
+			JavaEclipseLinkOneToManyMappingProvider.instance(),
+			JavaEclipseLinkOneToOneMappingProvider.instance(),
+			JavaEclipseLinkVariableOneToOneMappingProvider.instance()};
 	}
-
+	
+	
+	// ********* mapping files *********	
+	
 	@Override
-	protected void addOrmAttributeMappingProvidersTo(List<OrmAttributeMappingProvider> providers) {
-		providers.add(OrmEclipseLinkBasicCollectionMapping1_1Provider.instance());
-		providers.add(OrmEclipseLinkBasicMapMapping1_1Provider.instance());
-		providers.add(OrmEclipseLinkTransformationMapping1_1Provider.instance());
-		providers.add(OrmEclipseLinkVariableOneToOneMapping1_1Provider.instance());
-		providers.add(OrmEclipseLinkBasicMapping1_1Provider.instance());
-		providers.add(OrmEclipseLinkIdMapping1_1Provider.instance());
-		providers.add(OrmEclipseLinkEmbeddedIdMapping1_1Provider.instance());
-		providers.add(OrmEclipseLinkEmbeddedMapping1_1Provider.instance());
-		providers.add(OrmEclipseLinkManyToManyMapping1_1Provider.instance());
-		providers.add(OrmEclipseLinkManyToOneMapping1_1Provider.instance());
-		providers.add(OrmEclipseLinkOneToManyMapping1_1Provider.instance());
-		providers.add(OrmEclipseLinkOneToOneMapping1_1Provider.instance());
-		providers.add(OrmEclipseLinkVersionMapping1_1Provider.instance());
-		providers.add(OrmEclipseLinkTransientMapping1_1Provider.instance());
-		providers.add(OrmEclipseLinkNullAttributeMapping1_1Provider.instance());
+	protected MappingFileDefinition[] buildMappingFileDefinitions() {
+		// order should not be important here
+		return new MappingFileDefinition[] {
+			GenericOrmMappingFileDefinition.instance(),
+			EclipseLinkMappingFileDefinition.instance(),
+			EclipseLink1_1MappingFileDefinition.instance()};
 	}
-
-
 }
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v1_1/context/EclipseLink1_1MappingFileDefinition.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v1_1/context/EclipseLink1_1MappingFileDefinition.java
new file mode 100644
index 0000000000..77a0da69ef
--- /dev/null
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v1_1/context/EclipseLink1_1MappingFileDefinition.java
@@ -0,0 +1,112 @@
+/*******************************************************************************
+ * Copyright (c) 2009 Oracle. All rights reserved.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0, which accompanies this distribution
+ * and is available at http://www.eclipse.org/legal/epl-v10.html.
+ * 
+ * Contributors:
+ *     Oracle - initial API and implementation
+ ******************************************************************************/
+package org.eclipse.jpt.eclipselink.core.internal.v1_1.context;
+
+import org.eclipse.core.runtime.content.IContentType;
+import org.eclipse.jpt.core.JpaFactory;
+import org.eclipse.jpt.core.context.MappingFile;
+import org.eclipse.jpt.core.context.MappingFileDefinition;
+import org.eclipse.jpt.core.context.orm.OrmAttributeMappingProvider;
+import org.eclipse.jpt.core.context.orm.OrmTypeMappingProvider;
+import org.eclipse.jpt.core.context.persistence.MappingFileRef;
+import org.eclipse.jpt.core.internal.platform.AbstractMappingFileDefinition;
+import org.eclipse.jpt.core.resource.xml.JpaXmlResource;
+import org.eclipse.jpt.eclipselink.core.internal.JptEclipseLinkCorePlugin;
+import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkEmbeddableProvider;
+import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkEntityProvider;
+import org.eclipse.jpt.eclipselink.core.internal.context.orm.OrmEclipseLinkMappedSuperclassProvider;
+import org.eclipse.jpt.eclipselink.core.internal.v1_1.EclipseLink1_1JpaFactory;
+import org.eclipse.jpt.eclipselink.core.internal.v1_1.context.orm.OrmEclipseLinkBasicCollectionMapping1_1Provider;
+import org.eclipse.jpt.eclipselink.core.internal.v1_1.context.orm.OrmEclipseLinkBasicMapMapping1_1Provider;
+import org.eclipse.jpt.eclipselink.core.internal.v1_1.context.orm.OrmEclipseLinkBasicMapping1_1Provider;
+import org.eclipse.jpt.eclipselink.core.internal.v1_1.context.orm.OrmEclipseLinkEmbeddedIdMapping1_1Provider;
+import org.eclipse.jpt.eclipselink.core.internal.v1_1.context.orm.OrmEclipseLinkEmbeddedMapping1_1Provider;
+import org.eclipse.jpt.eclipselink.core.internal.v1_1.context.orm.OrmEclipseLinkIdMapping1_1Provider;
+import org.eclipse.jpt.eclipselink.core.internal.v1_1.context.orm.OrmEclipseLinkManyToManyMapping1_1Provider;
+import org.eclipse.jpt.eclipselink.core.internal.v1_1.context.orm.OrmEclipseLinkManyToOneMapping1_1Provider;
+import org.eclipse.jpt.eclipselink.core.internal.v1_1.context.orm.OrmEclipseLinkNullAttributeMapping1_1Provider;
+import org.eclipse.jpt.eclipselink.core.internal.v1_1.context.orm.OrmEclipseLinkOneToManyMapping1_1Provider;
+import org.eclipse.jpt.eclipselink.core.internal.v1_1.context.orm.OrmEclipseLinkOneToOneMapping1_1Provider;
+import org.eclipse.jpt.eclipselink.core.internal.v1_1.context.orm.OrmEclipseLinkTransformationMapping1_1Provider;
+import org.eclipse.jpt.eclipselink.core.internal.v1_1.context.orm.OrmEclipseLinkTransientMapping1_1Provider;
+import org.eclipse.jpt.eclipselink.core.internal.v1_1.context.orm.OrmEclipseLinkVariableOneToOneMapping1_1Provider;
+import org.eclipse.jpt.eclipselink.core.internal.v1_1.context.orm.OrmEclipseLinkVersionMapping1_1Provider;
+
+public class EclipseLink1_1MappingFileDefinition
+	extends AbstractMappingFileDefinition
+{
+	// singleton
+	private static final MappingFileDefinition INSTANCE = 
+			new EclipseLink1_1MappingFileDefinition();
+	
+	
+	/**
+	 * Return the singleton.
+	 */
+	public static MappingFileDefinition instance() {
+		return INSTANCE;
+	}
+	
+	
+	/**
+	 * Enforce singleton usage
+	 */
+	private EclipseLink1_1MappingFileDefinition() {
+		super();
+	}
+	
+	
+	public IContentType getContentType() {
+		return JptEclipseLinkCorePlugin.ECLIPSELINK1_1_ORM_XML_CONTENT_TYPE;
+	}
+	
+	public MappingFile buildMappingFile(MappingFileRef parent, JpaXmlResource resource, JpaFactory factory) {
+		return ((EclipseLink1_1JpaFactory) factory).buildEclipseLink1_1MappingFile(parent, resource);
+	}
+	
+	
+	// ********* ORM type mappings *********
+	
+	@Override
+	protected OrmTypeMappingProvider[] buildOrmTypeMappingProviders() {
+		// order should not matter here, but we'll use the same order as for java
+		// @see {@link EclipseLink1_1JpaPlatformProvider}
+		// NOTE: no new type mapping providers from eclipselink 1.0 to 1.1
+		return new OrmTypeMappingProvider[] {
+			OrmEclipseLinkEntityProvider.instance(),
+			OrmEclipseLinkEmbeddableProvider.instance(),
+			OrmEclipseLinkMappedSuperclassProvider.instance()};
+	}
+	
+	
+	// ********** ORM attribute mappings **********
+	
+	@Override
+	protected OrmAttributeMappingProvider[] buildOrmAttributeMappingProviders() {
+		// order should not matter here, but we'll use the same order as for java
+		// @see {@link EclipseLink1_1JpaPlatformProvider}
+		return new OrmAttributeMappingProvider[] {
+			OrmEclipseLinkTransientMapping1_1Provider.instance(),
+			OrmEclipseLinkBasicCollectionMapping1_1Provider.instance(),
+			OrmEclipseLinkBasicMapMapping1_1Provider.instance(),
+			OrmEclipseLinkIdMapping1_1Provider.instance(),
+			OrmEclipseLinkVersionMapping1_1Provider.instance(),
+			OrmEclipseLinkBasicMapping1_1Provider.instance(),
+			OrmEclipseLinkEmbeddedMapping1_1Provider.instance(),
+			OrmEclipseLinkEmbeddedIdMapping1_1Provider.instance(),
+			OrmEclipseLinkTransformationMapping1_1Provider.instance(),
+			OrmEclipseLinkManyToManyMapping1_1Provider.instance(),
+			OrmEclipseLinkManyToOneMapping1_1Provider.instance(),
+			OrmEclipseLinkOneToManyMapping1_1Provider.instance(),
+			OrmEclipseLinkOneToOneMapping1_1Provider.instance(),
+			OrmEclipseLinkVariableOneToOneMapping1_1Provider.instance(),
+			OrmEclipseLinkNullAttributeMapping1_1Provider.instance()};
+	}
+}
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v1_1/context/EclipseLinkMappingFile1_1Provider.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v1_1/context/EclipseLinkMappingFile1_1Provider.java
deleted file mode 100644
index 934d1010b7..0000000000
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v1_1/context/EclipseLinkMappingFile1_1Provider.java
+++ /dev/null
@@ -1,48 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2009 Oracle. All rights reserved.
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0, which accompanies this distribution
- * and is available at http://www.eclipse.org/legal/epl-v10.html.
- * 
- * Contributors:
- *     Oracle - initial API and implementation
- ******************************************************************************/
-package org.eclipse.jpt.eclipselink.core.internal.v1_1.context;
-
-import org.eclipse.core.runtime.content.IContentType;
-import org.eclipse.jpt.core.JpaFactory;
-import org.eclipse.jpt.core.context.MappingFile;
-import org.eclipse.jpt.core.context.MappingFileProvider;
-import org.eclipse.jpt.core.context.persistence.MappingFileRef;
-import org.eclipse.jpt.core.resource.xml.JpaXmlResource;
-import org.eclipse.jpt.eclipselink.core.internal.JptEclipseLinkCorePlugin;
-import org.eclipse.jpt.eclipselink.core.internal.v1_1.EclipseLink1_1JpaFactory;
-
-public class EclipseLinkMappingFile1_1Provider
-	implements MappingFileProvider
-{
-	// singleton
-	private static final MappingFileProvider INSTANCE = new EclipseLinkMappingFile1_1Provider();
-
-	/**
-	 * Return the singleton.
-	 */
-	public static MappingFileProvider instance() {
-		return INSTANCE;
-	}
-
-	/**
-	 * Ensure single instance.
-	 */
-	private EclipseLinkMappingFile1_1Provider() {
-		super();
-	}
-	public IContentType getContentType() {
-		return JptEclipseLinkCorePlugin.ECLIPSELINK1_1_ORM_XML_CONTENT_TYPE;
-	}
-
-	public MappingFile buildMappingFile(MappingFileRef parent, JpaXmlResource resource, JpaFactory factory) {
-		return ((EclipseLink1_1JpaFactory) factory).buildEclipseLink1_1MappingFile(parent, resource);
-	}
-
-}
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v1_1/context/orm/VirtuaEclipseLinklXmlNullAttributeMapping1_1.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v1_1/context/orm/VirtuaEclipseLinklXmlNullAttributeMapping1_1.java
index 502dd89f63..ec29e2bc89 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v1_1/context/orm/VirtuaEclipseLinklXmlNullAttributeMapping1_1.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v1_1/context/orm/VirtuaEclipseLinklXmlNullAttributeMapping1_1.java
@@ -24,7 +24,9 @@ import org.eclipse.jpt.eclipselink.core.v1_1.resource.orm.XmlAttributeMapping;
  * VirtualVersion is an implementation of Version used when there is 
  * no tag in the orm.xml and an underlying javaVersionMapping exists.
  */
-public class VirtuaEclipseLinklXmlNullAttributeMapping1_1 extends XmlNullAttributeMapping implements XmlAttributeMapping
+public class VirtuaEclipseLinklXmlNullAttributeMapping1_1
+	extends XmlNullAttributeMapping 
+	implements XmlAttributeMapping
 {
 	
 	protected OrmTypeMapping ormTypeMapping;
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/resource/orm/XmlAttributeMapping.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/resource/orm/XmlAttributeMapping.java
index 7fe7996afc..cee85f7a54 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/resource/orm/XmlAttributeMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/resource/orm/XmlAttributeMapping.java
@@ -26,6 +26,8 @@ package org.eclipse.jpt.eclipselink.core.resource.orm;
  * @model kind="class" interface="true" abstract="true"
  * @generated
  */
-public interface XmlAttributeMapping extends org.eclipse.jpt.core.resource.orm.XmlAttributeMapping, XmlAccessMethodsHolder, XmlPropertyContainer
+public interface XmlAttributeMapping 
+	extends org.eclipse.jpt.core.resource.orm.XmlAttributeMapping, 
+			XmlAccessMethodsHolder, XmlPropertyContainer
 {
 } // XmlAttributeMapping
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/v1_1/resource/orm/XmlAttributeMapping.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/v1_1/resource/orm/XmlAttributeMapping.java
index 77e6bcf809..a726d621de 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/v1_1/resource/orm/XmlAttributeMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/v1_1/resource/orm/XmlAttributeMapping.java
@@ -21,6 +21,8 @@ import org.eclipse.jpt.core.resource.orm.XmlAccessHolder;
  * @model kind="class" interface="true" abstract="true"
  * @generated
  */
-public interface XmlAttributeMapping extends org.eclipse.jpt.eclipselink.core.resource.orm.XmlAttributeMapping, XmlAccessHolder
+public interface XmlAttributeMapping
+	extends org.eclipse.jpt.eclipselink.core.resource.orm.XmlAttributeMapping, 
+			XmlAccessHolder
 {
 } // XmlAttributeMapping