changed default mapping to use a null resource even if the resource exists. This is for basic mappings and embedded mappings

19 files changed, 281 insertions, 286 deletions

diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaAttributeMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaAttributeMapping.java
index 3fa33ad649..791c34268f 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaAttributeMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaAttributeMapping.java
@@ -26,9 +26,9 @@ public interface JavaAttributeMapping extends AttributeMapping, JavaJpaContextNo
 {
 	JavaPersistentAttribute persistentAttribute();
 	
-	void initializeFromResource(JavaResourcePersistentAttribute persistentAttributeResource);
+	void initializeFromResource(JavaResourcePersistentAttribute resourcePersistentAttribute);
 
-	void update(JavaResourcePersistentAttribute persistentAttributeResource);
+	void update(JavaResourcePersistentAttribute resourcePersistentAttribute);
 	
 	String annotationName();
 	
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaAttributeMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaAttributeMapping.java
index ecc414121b..b443b3429c 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaAttributeMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaAttributeMapping.java
@@ -26,34 +26,38 @@ import org.eclipse.jpt.db.Table;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
 
-public abstract class AbstractJavaAttributeMapping extends AbstractJavaJpaContextNode
+public abstract class AbstractJavaAttributeMapping<T extends JavaResourceNode> extends AbstractJavaJpaContextNode
 	implements JavaAttributeMapping
 {
-	protected JavaResourcePersistentAttribute persistentAttributeResource;
+	protected JavaResourcePersistentAttribute resourcePersistentAttribute;
 	
 
 	protected AbstractJavaAttributeMapping(JavaPersistentAttribute parent) {
 		super(parent);
 	}
-
-	public void initializeFromResource(JavaResourcePersistentAttribute persistentAttributeResource) {
-		this.persistentAttributeResource = persistentAttributeResource;
-	}
-
-	protected JavaResourceNode mappingResource() {
-		return this.persistentAttributeResource.mappingAnnotation(annotationName());
+	
+	@SuppressWarnings("unchecked")
+	protected T mappingResource() {
+		if (isDefault()) {
+			return (T) this.resourcePersistentAttribute.nullMappingAnnotation(annotationName());
+		}
+		return (T) this.resourcePersistentAttribute.mappingAnnotation(annotationName());
 	}
 	
 	public GenericJavaPersistentAttribute persistentAttribute() {
 		return (GenericJavaPersistentAttribute) this.parent();
 	}
 
+	protected JavaResourcePersistentAttribute getResourcePersistentAttribute() {
+		return this.resourcePersistentAttribute;
+	}
+	
 	/**
 	 * the persistent attribute can tell whether there is a "specified" mapping
 	 * or a "default" one
 	 */
 	public boolean isDefault() {
-		return this.persistentAttribute().mappingIsDefault();
+		return this.persistentAttribute().mappingIsDefault(this);
 	}
 
 	protected boolean embeddableOwned() {
@@ -80,11 +84,7 @@ public abstract class AbstractJavaAttributeMapping extends AbstractJavaJpaContex
 		TextRange textRange = this.mappingResource().textRange(astRoot);
 		return (textRange != null) ? textRange : this.persistentAttribute().validationTextRange(astRoot);
 	}
-
-	public void update(JavaResourcePersistentAttribute persistentAttributeResource) {
-		this.persistentAttributeResource = persistentAttributeResource;
-	}
-
+	
 	public String primaryKeyColumnName() {
 		return null;
 	}
@@ -100,6 +100,25 @@ public abstract class AbstractJavaAttributeMapping extends AbstractJavaJpaContex
 	public boolean isIdMapping() {
 		return false;
 	}
+
+	public void initializeFromResource(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		this.resourcePersistentAttribute = resourcePersistentAttribute;
+		initialize(mappingResource());
+	}
+
+	protected void initialize(T mappingResource) {
+		
+	}
+
+	public void update(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		this.resourcePersistentAttribute = resourcePersistentAttribute;
+		this.update(mappingResource());
+	}
+	
+	protected void update(T mappingResource) {
+		
+	}
+
 	
 	//************ Validation *************************
 	
@@ -115,11 +134,11 @@ public abstract class AbstractJavaAttributeMapping extends AbstractJavaJpaContex
 	protected void addModifierMessages(List<IMessage> messages, CompilationUnit astRoot) {
 		GenericJavaPersistentAttribute attribute = this.persistentAttribute();
 		if (attribute.getMapping().getKey() != MappingKeys.TRANSIENT_ATTRIBUTE_MAPPING_KEY
-				&& persistentAttributeResource.isForField()) {
+				&& this.resourcePersistentAttribute.isForField()) {
 			int flags;
 			
 			try {
-				flags = persistentAttributeResource.getMember().getJdtMember().getFlags();
+				flags = this.resourcePersistentAttribute.getMember().getJdtMember().getFlags();
 			} catch (JavaModelException jme) { 
 				/* no error to log, in that case */ 
 				return;
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaMultiRelationshipMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaMultiRelationshipMapping.java
index ae91ded57d..e50d54bc15 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaMultiRelationshipMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaMultiRelationshipMapping.java
@@ -97,15 +97,15 @@ public abstract class AbstractJavaMultiRelationshipMapping<T extends Relationshi
 	}
 	
 	protected OrderBy orderByResource() {
-		return (OrderBy) this.persistentAttributeResource.annotation(OrderBy.ANNOTATION_NAME);
+		return (OrderBy) getResourcePersistentAttribute().annotation(OrderBy.ANNOTATION_NAME);
 	}
 	
 	protected OrderBy addOrderByResource() {
-		return (OrderBy) this.persistentAttributeResource.addAnnotation(OrderBy.ANNOTATION_NAME);
+		return (OrderBy) getResourcePersistentAttribute().addAnnotation(OrderBy.ANNOTATION_NAME);
 	}
 	
 	protected void removeOrderByResource() {
-		this.persistentAttributeResource.removeAnnotation(OrderBy.ANNOTATION_NAME);
+		getResourcePersistentAttribute().removeAnnotation(OrderBy.ANNOTATION_NAME);
 	}
 	
 	public boolean isNoOrdering() {
@@ -199,17 +199,17 @@ public abstract class AbstractJavaMultiRelationshipMapping<T extends Relationshi
 		String oldMapKey = this.mapKey;
 		this.mapKey = newMapKey;
 		if (oldMapKey != newMapKey) {
-			if (this.mapKeyResource(this.persistentAttributeResource) != null) {
+			if (this.mapKeyResource(getResourcePersistentAttribute()) != null) {
 				if (newMapKey != null) {
-					this.mapKeyResource(this.persistentAttributeResource).setName(newMapKey);
+					this.mapKeyResource(getResourcePersistentAttribute()).setName(newMapKey);
 				}
 				else {
-					this.persistentAttributeResource.removeAnnotation(MapKey.ANNOTATION_NAME);				
+					getResourcePersistentAttribute().removeAnnotation(MapKey.ANNOTATION_NAME);				
 				}
 			}
 			else if (newMapKey != null) {
-				this.persistentAttributeResource.addAnnotation(MapKey.ANNOTATION_NAME);
-				mapKeyResource(this.persistentAttributeResource).setName(newMapKey);
+				getResourcePersistentAttribute().addAnnotation(MapKey.ANNOTATION_NAME);
+				mapKeyResource(getResourcePersistentAttribute()).setName(newMapKey);
 			}
 		}
 		firePropertyChanged(MultiRelationshipMapping.MAP_KEY_PROPERTY, oldMapKey, newMapKey);
@@ -238,24 +238,24 @@ public abstract class AbstractJavaMultiRelationshipMapping<T extends Relationshi
 //	}
 
 	@Override
-	protected String defaultTargetEntity(JavaResourcePersistentAttribute persistentAttributeResource) {
-		if (!persistentAttributeResource.typeIsContainer()) {
+	protected String defaultTargetEntity(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		if (!resourcePersistentAttribute.typeIsContainer()) {
 			return null;
 		}
-		return persistentAttributeResource.getQualifiedReferenceEntityElementTypeName();
+		return resourcePersistentAttribute.getQualifiedReferenceEntityElementTypeName();
 	}
 	
 	protected abstract boolean mappedByTouches(int pos, CompilationUnit astRoot);
 
 	protected boolean mapKeyNameTouches(int pos, CompilationUnit astRoot) {
-		if (mapKeyResource(this.persistentAttributeResource) != null) {
-			return mapKeyResource(this.persistentAttributeResource).nameTouches(pos, astRoot);
+		if (mapKeyResource(getResourcePersistentAttribute()) != null) {
+			return mapKeyResource(getResourcePersistentAttribute()).nameTouches(pos, astRoot);
 		}
 		return false;
 	}
 	
-	protected MapKey mapKeyResource(JavaResourcePersistentAttribute persistentAttributeResource) {
-		return (MapKey) persistentAttributeResource.annotation(MapKey.ANNOTATION_NAME);
+	protected MapKey mapKeyResource(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		return (MapKey) resourcePersistentAttribute.annotation(MapKey.ANNOTATION_NAME);
 	}
 
 	public Iterator<String> candidateMapKeyNames() {
@@ -290,14 +290,14 @@ public abstract class AbstractJavaMultiRelationshipMapping<T extends Relationshi
 	}
 	
 	@Override
-	public void initializeFromResource(JavaResourcePersistentAttribute persistentAttributeResource) {
-		super.initializeFromResource(persistentAttributeResource);
-		MapKey mapKey = this.mapKeyResource(persistentAttributeResource);
+	public void initializeFromResource(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		super.initializeFromResource(resourcePersistentAttribute);
+		MapKey mapKey = this.mapKeyResource(resourcePersistentAttribute);
 		if (mapKey != null) {
 			this.mapKey = mapKey.getName();
 		}
 		this.initializeOrderBy(this.orderByResource());
-		this.joinTable.initializeFromResource(persistentAttributeResource);
+		this.joinTable.initializeFromResource(resourcePersistentAttribute);
 	}
 	
 	@Override
@@ -322,11 +322,11 @@ public abstract class AbstractJavaMultiRelationshipMapping<T extends Relationshi
 	}
 	
 	@Override
-	public void update(JavaResourcePersistentAttribute persistentAttributeResource) {
-		super.update(persistentAttributeResource);
-		this.updateMapKey(persistentAttributeResource);
+	public void update(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		super.update(resourcePersistentAttribute);
+		this.updateMapKey(resourcePersistentAttribute);
 		this.updateOrderBy(this.orderByResource());
-		this.joinTable.update(persistentAttributeResource);
+		this.joinTable.update(resourcePersistentAttribute);
 	}	
 	
 	@Override
@@ -335,8 +335,8 @@ public abstract class AbstractJavaMultiRelationshipMapping<T extends Relationshi
 		this.setMappedBy(this.mappedBy(relationshipMapping));
 	}
 	
-	protected void updateMapKey(JavaResourcePersistentAttribute persistentAttributeResource) {
-		MapKey mapKey = this.mapKeyResource(persistentAttributeResource);
+	protected void updateMapKey(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		MapKey mapKey = this.mapKeyResource(resourcePersistentAttribute);
 		if (mapKey != null) {
 			setMapKey_(mapKey.getName());
 		}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaRelationshipMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaRelationshipMapping.java
index 06540bfbb4..bc32719eba 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaRelationshipMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaRelationshipMapping.java
@@ -26,7 +26,7 @@ import org.eclipse.jpt.utility.internal.StringTools;
 import org.eclipse.jpt.utility.internal.iterators.EmptyIterator;
 import org.eclipse.jpt.utility.internal.iterators.FilteringIterator;
 
-public abstract class AbstractJavaRelationshipMapping<T extends RelationshipMappingAnnotation> extends AbstractJavaAttributeMapping
+public abstract class AbstractJavaRelationshipMapping<T extends RelationshipMappingAnnotation> extends AbstractJavaAttributeMapping<T>
 	implements JavaRelationshipMapping
 {
 
@@ -44,8 +44,6 @@ public abstract class AbstractJavaRelationshipMapping<T extends RelationshipMapp
 		super(parent);
 		this.cascade = new JavaCascade(this);
 	}
-
-	protected abstract T relationshipMapping();
 	
 	public String getTargetEntity() {
 		return (this.getSpecifiedTargetEntity() == null) ? getDefaultTargetEntity() : this.getSpecifiedTargetEntity();
@@ -58,7 +56,7 @@ public abstract class AbstractJavaRelationshipMapping<T extends RelationshipMapp
 	public void setSpecifiedTargetEntity(String newSpecifiedTargetEntity) {
 		String oldSpecifiedTargetEntity = this.specifiedTargetEntity;
 		this.specifiedTargetEntity = newSpecifiedTargetEntity;
-		this.relationshipMapping().setTargetEntity(newSpecifiedTargetEntity);
+		this.mappingResource().setTargetEntity(newSpecifiedTargetEntity);
 		firePropertyChanged(RelationshipMapping.SPECIFIED_TARGET_ENTITY_PROPERTY, oldSpecifiedTargetEntity, newSpecifiedTargetEntity);
 	}
 
@@ -97,24 +95,23 @@ public abstract class AbstractJavaRelationshipMapping<T extends RelationshipMapp
 	public void setSpecifiedFetch(FetchType newSpecifiedFetch) {
 		FetchType oldFetch = this.specifiedFetch;
 		this.specifiedFetch = newSpecifiedFetch;
-		this.relationshipMapping().setFetch(FetchType.toJavaResourceModel(newSpecifiedFetch));
+		this.mappingResource().setFetch(FetchType.toJavaResourceModel(newSpecifiedFetch));
 		firePropertyChanged(Fetchable.SPECIFIED_FETCH_PROPERTY, oldFetch, newSpecifiedFetch);
 	}
 
 	@Override
-	public void initializeFromResource(JavaResourcePersistentAttribute persistentAttributeResource) {
-		super.initializeFromResource(persistentAttributeResource);
-		this.defaultTargetEntity = this.defaultTargetEntity(persistentAttributeResource);
-		initialize(this.relationshipMapping());
+	public void initializeFromResource(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		super.initializeFromResource(resourcePersistentAttribute);
+		this.defaultTargetEntity = this.defaultTargetEntity(resourcePersistentAttribute);
 	}
 	
 	@Override
-	public void update(JavaResourcePersistentAttribute persistentAttributeResource) {
-		super.update(persistentAttributeResource);
-		this.setDefaultTargetEntity(this.defaultTargetEntity(persistentAttributeResource));
-		this.update(this.relationshipMapping());
+	public void update(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		super.update(resourcePersistentAttribute);
+		this.setDefaultTargetEntity(this.defaultTargetEntity(resourcePersistentAttribute));
 	}
 	
+	@Override
 	protected void initialize(T relationshipMapping) {
 		this.specifiedFetch = this.fetch(relationshipMapping);
 		this.cascade.initialize(relationshipMapping);
@@ -122,6 +119,7 @@ public abstract class AbstractJavaRelationshipMapping<T extends RelationshipMapp
 		this.resolvedTargetEntity = this.resolveTargetEntity(relationshipMapping);
 	}
 
+	@Override
 	protected void update(T relationshipMapping) {
 		this.setSpecifiedFetch(this.fetch(relationshipMapping));
 		this.cascade.update(relationshipMapping);
@@ -137,7 +135,7 @@ public abstract class AbstractJavaRelationshipMapping<T extends RelationshipMapp
 		return relationshipMapping.getTargetEntity();
 	}
 	
-	protected abstract String defaultTargetEntity(JavaResourcePersistentAttribute persistentAttributeResource);
+	protected abstract String defaultTargetEntity(JavaResourcePersistentAttribute resourcePersistentAttribute);
 	
 	protected Entity resolveTargetEntity(T relationshipMapping) {
 		String qualifiedTargetEntity = getDefaultTargetEntity();
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaSingleRelationshipMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaSingleRelationshipMapping.java
index 8fdab63c2d..9f13e79f77 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaSingleRelationshipMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaSingleRelationshipMapping.java
@@ -115,7 +115,7 @@ public abstract class AbstractJavaSingleRelationshipMapping<T extends Relationsh
 		}
 		JavaJoinColumn joinColumn = jpaFactory().buildJavaJoinColumn(this, createJoinColumnOwner());
 		this.specifiedJoinColumns.add(index, joinColumn);
-		JoinColumnAnnotation joinColumnResource = (JoinColumnAnnotation) this.persistentAttributeResource.addAnnotation(index, JoinColumnAnnotation.ANNOTATION_NAME, JoinColumns.ANNOTATION_NAME);
+		JoinColumnAnnotation joinColumnResource = (JoinColumnAnnotation) getResourcePersistentAttribute().addAnnotation(index, JoinColumnAnnotation.ANNOTATION_NAME, JoinColumns.ANNOTATION_NAME);
 		joinColumn.initializeFromResource(joinColumnResource);
 		this.fireItemAdded(SingleRelationshipMapping.SPECIFIED_JOIN_COLUMNS_LIST, index, joinColumn);
 		if (oldDefaultJoinColumn != null) {
@@ -138,9 +138,9 @@ public abstract class AbstractJavaSingleRelationshipMapping<T extends Relationsh
 			//create the defaultJoinColumn now or this will happen during project update 
 			//after removing the join column from the resource model. That causes problems 
 			//in the UI because the change notifications end up in the wrong order.
-			this.defaultJoinColumn = buildJoinColumn(new NullJoinColumn(this.persistentAttributeResource));
+			this.defaultJoinColumn = buildJoinColumn(new NullJoinColumn(getResourcePersistentAttribute()));
 		}
-		this.persistentAttributeResource.removeAnnotation(index, JoinColumnAnnotation.ANNOTATION_NAME, JoinColumns.ANNOTATION_NAME);
+		getResourcePersistentAttribute().removeAnnotation(index, JoinColumnAnnotation.ANNOTATION_NAME, JoinColumns.ANNOTATION_NAME);
 		fireItemRemoved(SingleRelationshipMapping.SPECIFIED_JOIN_COLUMNS_LIST, index, removedJoinColumn);
 		if (this.defaultJoinColumn != null) {
 			//fire change notification if a defaultJoinColumn was created above
@@ -154,7 +154,7 @@ public abstract class AbstractJavaSingleRelationshipMapping<T extends Relationsh
 	
 	public void moveSpecifiedJoinColumn(int targetIndex, int sourceIndex) {
 		CollectionTools.move(this.specifiedJoinColumns, targetIndex, sourceIndex);
-		this.persistentAttributeResource.move(targetIndex, sourceIndex, JoinColumns.ANNOTATION_NAME);
+		getResourcePersistentAttribute().move(targetIndex, sourceIndex, JoinColumns.ANNOTATION_NAME);
 		fireItemMoved(SingleRelationshipMapping.SPECIFIED_JOIN_COLUMNS_LIST, targetIndex, sourceIndex);		
 	}
 
@@ -181,10 +181,10 @@ public abstract class AbstractJavaSingleRelationshipMapping<T extends Relationsh
 
 
 	@Override
-	public void initializeFromResource(JavaResourcePersistentAttribute persistentAttributeResource) {
-		super.initializeFromResource(persistentAttributeResource);
-		this.initializeSpecifiedJoinColumns(persistentAttributeResource);
-		this.initializeDefaultJoinColumn(persistentAttributeResource);
+	public void initializeFromResource(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		super.initializeFromResource(resourcePersistentAttribute);
+		this.initializeSpecifiedJoinColumns(resourcePersistentAttribute);
+		this.initializeDefaultJoinColumn(resourcePersistentAttribute);
 	}
 	
 	@Override
@@ -193,8 +193,8 @@ public abstract class AbstractJavaSingleRelationshipMapping<T extends Relationsh
 		this.specifiedOptional = this.specifiedOptional(relationshipMapping);
 	}
 	
-	protected void initializeSpecifiedJoinColumns(JavaResourcePersistentAttribute persistentAttributeResource) {
-		ListIterator<JavaResourceNode> annotations = persistentAttributeResource.annotations(JoinColumnAnnotation.ANNOTATION_NAME, JoinColumns.ANNOTATION_NAME);
+	protected void initializeSpecifiedJoinColumns(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		ListIterator<JavaResourceNode> annotations = resourcePersistentAttribute.annotations(JoinColumnAnnotation.ANNOTATION_NAME, JoinColumns.ANNOTATION_NAME);
 		
 		while(annotations.hasNext()) {
 			this.specifiedJoinColumns.add(buildJoinColumn((JoinColumnAnnotation) annotations.next()));
@@ -205,19 +205,19 @@ public abstract class AbstractJavaSingleRelationshipMapping<T extends Relationsh
 		return !containsSpecifiedJoinColumns() && isRelationshipOwner();
 	}
 	
-	protected void initializeDefaultJoinColumn(JavaResourcePersistentAttribute persistentAttributeResource) {
+	protected void initializeDefaultJoinColumn(JavaResourcePersistentAttribute resourcePersistentAttribute) {
 		if (!shouldBuildDefaultJoinColumn()) {
 			return;
 		}
-		this.defaultJoinColumn = buildJoinColumn(new NullJoinColumn(persistentAttributeResource));
+		this.defaultJoinColumn = buildJoinColumn(new NullJoinColumn(resourcePersistentAttribute));
 	}	
 	
 	
 	@Override
-	public void update(JavaResourcePersistentAttribute persistentAttributeResource) {
-		super.update(persistentAttributeResource);
-		this.updateSpecifiedJoinColumns(persistentAttributeResource);
-		this.updateDefaultJoinColumn(persistentAttributeResource);
+	public void update(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		super.update(resourcePersistentAttribute);
+		this.updateSpecifiedJoinColumns(resourcePersistentAttribute);
+		this.updateDefaultJoinColumn(resourcePersistentAttribute);
 	}
 	
 	@Override
@@ -229,9 +229,9 @@ public abstract class AbstractJavaSingleRelationshipMapping<T extends Relationsh
 	protected abstract Boolean specifiedOptional(T relationshipMapping);
 	
 	
-	protected void updateSpecifiedJoinColumns(JavaResourcePersistentAttribute persistentAttributeResource) {
+	protected void updateSpecifiedJoinColumns(JavaResourcePersistentAttribute resourcePersistentAttribute) {
 		ListIterator<JavaJoinColumn> joinColumns = specifiedJoinColumns();
-		ListIterator<JavaResourceNode> resourceJoinColumns = persistentAttributeResource.annotations(JoinColumnAnnotation.ANNOTATION_NAME, JoinColumns.ANNOTATION_NAME);
+		ListIterator<JavaResourceNode> resourceJoinColumns = resourcePersistentAttribute.annotations(JoinColumnAnnotation.ANNOTATION_NAME, JoinColumns.ANNOTATION_NAME);
 		
 		while (joinColumns.hasNext()) {
 			JavaJoinColumn joinColumn = joinColumns.next();
@@ -248,16 +248,16 @@ public abstract class AbstractJavaSingleRelationshipMapping<T extends Relationsh
 		}
 	}
 	
-	protected void updateDefaultJoinColumn(JavaResourcePersistentAttribute persistentAttributeResource) {
+	protected void updateDefaultJoinColumn(JavaResourcePersistentAttribute resourcePersistentAttribute) {
 		if (!shouldBuildDefaultJoinColumn()) {
 			setDefaultJoinColumn(null);
 			return;
 		}
 		if (getDefaultJoinColumn() == null) {
-			this.setDefaultJoinColumn(buildJoinColumn(new NullJoinColumn(persistentAttributeResource)));
+			this.setDefaultJoinColumn(buildJoinColumn(new NullJoinColumn(resourcePersistentAttribute)));
 		}
 		else {
-			this.defaultJoinColumn.update(new NullJoinColumn(persistentAttributeResource));
+			this.defaultJoinColumn.update(new NullJoinColumn(resourcePersistentAttribute));
 		}
 	}	
 
@@ -275,11 +275,11 @@ public abstract class AbstractJavaSingleRelationshipMapping<T extends Relationsh
 	 * eliminate any "container" types
 	 */
 	@Override
-	protected String defaultTargetEntity(JavaResourcePersistentAttribute persistentAttributeResource) {
-		if (persistentAttributeResource.typeIsContainer()) {
+	protected String defaultTargetEntity(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		if (resourcePersistentAttribute.typeIsContainer()) {
 			return null;
 		}
-		return persistentAttributeResource.getQualifiedReferenceEntityTypeName();
+		return resourcePersistentAttribute.getQualifiedReferenceEntityTypeName();
 	}
 
 	@Override
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaBasicMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaBasicMapping.java
index 9bac635a86..f807dc11d3 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaBasicMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaBasicMapping.java
@@ -37,7 +37,7 @@ import org.eclipse.jpt.utility.internal.iterators.ArrayIterator;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
 
-public class GenericJavaBasicMapping extends AbstractJavaAttributeMapping implements JavaBasicMapping
+public class GenericJavaBasicMapping extends AbstractJavaAttributeMapping<Basic> implements JavaBasicMapping
 {
 	protected FetchType specifiedFetch;
 
@@ -61,32 +61,30 @@ public class GenericJavaBasicMapping extends AbstractJavaAttributeMapping implem
 	}
 
 	@Override
-	public void initializeFromResource(JavaResourcePersistentAttribute persistentAttributeResource) {
-		super.initializeFromResource(persistentAttributeResource);
+	public void initializeFromResource(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		super.initializeFromResource(resourcePersistentAttribute);
 		this.column.initializeFromResource(this.columnResource());
-		Basic basicResource = this.mappingResource();
-		this.specifiedFetch = this.specifiedFetchType(basicResource);
-		this.specifiedOptional = this.specifiedOptional(basicResource);
 		this.specifiedEnumerated = this.specifiedEnumerated(this.enumeratedResource());
-		this.lob = this.lob(persistentAttributeResource);
+		this.lob = this.lob(resourcePersistentAttribute);
 		this.temporal = this.temporal(this.temporalResource());
 	}
 	
 	@Override
-	protected Basic mappingResource() {
-		return (Basic) this.persistentAttributeResource.nonNullMappingAnnotation(annotationName());
+	protected void initialize(Basic basicResource) {
+		this.specifiedFetch = this.specifiedFetchType(basicResource);
+		this.specifiedOptional = this.specifiedOptional(basicResource);
 	}
 	
 	protected Enumerated enumeratedResource() {
-		return (Enumerated) this.persistentAttributeResource.nonNullAnnotation(Enumerated.ANNOTATION_NAME);
+		return (Enumerated) getResourcePersistentAttribute().nonNullAnnotation(Enumerated.ANNOTATION_NAME);
 	}
 	
 	protected Temporal temporalResource() {
-		return (Temporal) this.persistentAttributeResource.nonNullAnnotation(Temporal.ANNOTATION_NAME);
+		return (Temporal) getResourcePersistentAttribute().nonNullAnnotation(Temporal.ANNOTATION_NAME);
 	}
 
 	public ColumnAnnotation columnResource() {
-		return (ColumnAnnotation) this.persistentAttributeResource.nonNullAnnotation(ColumnAnnotation.ANNOTATION_NAME);
+		return (ColumnAnnotation) getResourcePersistentAttribute().nonNullAnnotation(ColumnAnnotation.ANNOTATION_NAME);
 	}
 	
 	//************** IJavaAttributeMapping implementation ***************
@@ -170,6 +168,11 @@ public class GenericJavaBasicMapping extends AbstractJavaAttributeMapping implem
 		firePropertyChanged(Nullable.SPECIFIED_OPTIONAL_PROPERTY, oldOptional, newSpecifiedOptional);
 	}
 
+	protected void setSpecifiedOptional_(Boolean newSpecifiedOptional) {
+		Boolean oldOptional = this.specifiedOptional;
+		this.specifiedOptional = newSpecifiedOptional;
+		firePropertyChanged(Nullable.SPECIFIED_OPTIONAL_PROPERTY, oldOptional, newSpecifiedOptional);
+	}
 
 	public boolean isLob() {
 		return this.lob;
@@ -179,13 +182,13 @@ public class GenericJavaBasicMapping extends AbstractJavaAttributeMapping implem
 		boolean oldLob = this.lob;
 		this.lob = newLob;
 		if (newLob) {
-			if (lobResource(this.persistentAttributeResource) == null) {
-				this.persistentAttributeResource.addAnnotation(Lob.ANNOTATION_NAME);
+			if (lobResource(getResourcePersistentAttribute()) == null) {
+				getResourcePersistentAttribute().addAnnotation(Lob.ANNOTATION_NAME);
 			}
 		}
 		else {
-			if (lobResource(this.persistentAttributeResource) != null) {
-				this.persistentAttributeResource.removeAnnotation(Lob.ANNOTATION_NAME);
+			if (lobResource(getResourcePersistentAttribute()) != null) {
+				getResourcePersistentAttribute().removeAnnotation(Lob.ANNOTATION_NAME);
 			}
 		}
 		firePropertyChanged(BasicMapping.LOB_PROPERTY, oldLob, newLob);
@@ -246,17 +249,19 @@ public class GenericJavaBasicMapping extends AbstractJavaAttributeMapping implem
 	}
 
 	@Override
-	public void update(JavaResourcePersistentAttribute persistentAttributeResource) {
-		super.update(persistentAttributeResource);
+	public void update(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		super.update(resourcePersistentAttribute);
 		this.column.update(this.columnResource());
-		Basic basicResource = this.mappingResource();
-		this.setSpecifiedFetch_(this.specifiedFetchType(basicResource));
-		this.setSpecifiedOptional(this.specifiedOptional(basicResource));
 		this.setSpecifiedEnumerated_(this.specifiedEnumerated(this.enumeratedResource()));
-		this.setLob(this.lob(persistentAttributeResource));
+		this.setLob(this.lob(resourcePersistentAttribute));
 		this.setTemporal_(this.temporal(this.temporalResource()));
 	}
 	
+	@Override
+	protected void update(Basic basicResource) {
+		this.setSpecifiedFetch_(this.specifiedFetchType(basicResource));
+		this.setSpecifiedOptional_(this.specifiedOptional(basicResource));
+	}
 	
 	protected FetchType specifiedFetchType(Basic basic) {
 		return FetchType.fromJavaResourceModel(basic.getFetch());
@@ -270,12 +275,12 @@ public class GenericJavaBasicMapping extends AbstractJavaAttributeMapping implem
 		return EnumType.fromJavaResourceModel(enumerated.getValue());
 	}
 	
-	protected boolean lob(JavaResourcePersistentAttribute persistentAttributeResource) {
-		return lobResource(persistentAttributeResource) != null;
+	protected boolean lob(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		return lobResource(resourcePersistentAttribute) != null;
 	}
 	
-	protected Lob lobResource(JavaResourcePersistentAttribute persistentAttributeResource) {
-		return (Lob) persistentAttributeResource.annotation(Lob.ANNOTATION_NAME);
+	protected Lob lobResource(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		return (Lob) resourcePersistentAttribute.annotation(Lob.ANNOTATION_NAME);
 	}
 	
 	protected TemporalType temporal(Temporal temporal) {
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaEmbeddedIdMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaEmbeddedIdMapping.java
index 1a3e6fdaea..170f435508 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaEmbeddedIdMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaEmbeddedIdMapping.java
@@ -44,7 +44,7 @@ import org.eclipse.jpt.utility.internal.iterators.TransformationIterator;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
 
-public class GenericJavaEmbeddedIdMapping extends AbstractJavaAttributeMapping
+public class GenericJavaEmbeddedIdMapping extends AbstractJavaAttributeMapping<EmbeddedId>
 	implements JavaEmbeddedIdMapping
 {
 	protected final List<JavaAttributeOverride> specifiedAttributeOverrides;
@@ -120,7 +120,7 @@ public class GenericJavaEmbeddedIdMapping extends AbstractJavaAttributeMapping
 	public JavaAttributeOverride addSpecifiedAttributeOverride(int index) {
 		JavaAttributeOverride attributeOverride = jpaFactory().buildJavaAttributeOverride(this, this);
 		this.specifiedAttributeOverrides.add(index, attributeOverride);
-		AttributeOverrideAnnotation attributeOverrideResource = (AttributeOverrideAnnotation) this.persistentAttributeResource.addAnnotation(index, AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverrides.ANNOTATION_NAME);
+		AttributeOverrideAnnotation attributeOverrideResource = (AttributeOverrideAnnotation) getResourcePersistentAttribute().addAnnotation(index, AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverrides.ANNOTATION_NAME);
 		attributeOverride.initializeFromResource(attributeOverrideResource);
 		this.fireItemAdded(EmbeddedIdMapping.SPECIFIED_ATTRIBUTE_OVERRIDES_LIST, index, attributeOverride);
 		return attributeOverride;
@@ -143,12 +143,12 @@ public class GenericJavaEmbeddedIdMapping extends AbstractJavaAttributeMapping
 		JavaAttributeOverride defaultAttributeOverride = null;
 		if (removedAttributeOverride.getName() != null) {
 			if (CollectionTools.contains(allOverridableAttributeNames(), removedAttributeOverride.getName())) {
-				defaultAttributeOverride = createAttributeOverride(new NullAttributeOverride(this.persistentAttributeResource, removedAttributeOverride.getName()));
+				defaultAttributeOverride = createAttributeOverride(new NullAttributeOverride(getResourcePersistentAttribute(), removedAttributeOverride.getName()));
 				this.defaultAttributeOverrides.add(defaultAttributeOverride);
 			}
 		}
 		
-		this.persistentAttributeResource.removeAnnotation(index, AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverrides.ANNOTATION_NAME);
+		getResourcePersistentAttribute().removeAnnotation(index, AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverrides.ANNOTATION_NAME);
 		fireItemRemoved(EmbeddedIdMapping.SPECIFIED_ATTRIBUTE_OVERRIDES_LIST, index, removedAttributeOverride);
 	
 		if (defaultAttributeOverride != null) {
@@ -162,7 +162,7 @@ public class GenericJavaEmbeddedIdMapping extends AbstractJavaAttributeMapping
 
 	public void moveSpecifiedAttributeOverride(int targetIndex, int sourceIndex) {
 		CollectionTools.move(this.specifiedAttributeOverrides, targetIndex, sourceIndex);
-		this.persistentAttributeResource.move(targetIndex, sourceIndex, AttributeOverrides.ANNOTATION_NAME);
+		getResourcePersistentAttribute().move(targetIndex, sourceIndex, AttributeOverrides.ANNOTATION_NAME);
 		fireItemMoved(EmbeddedIdMapping.SPECIFIED_ATTRIBUTE_OVERRIDES_LIST, targetIndex, sourceIndex);		
 	}
 	
@@ -214,15 +214,15 @@ public class GenericJavaEmbeddedIdMapping extends AbstractJavaAttributeMapping
 	
 	
 	@Override
-	public void initializeFromResource(JavaResourcePersistentAttribute persistentAttributeResource) {
-		super.initializeFromResource(persistentAttributeResource);
-		this.initializeAttributeOverrides(persistentAttributeResource);
-		this.initializeDefaultAttributeOverrides(persistentAttributeResource);
+	public void initializeFromResource(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		super.initializeFromResource(resourcePersistentAttribute);
+		this.initializeAttributeOverrides(resourcePersistentAttribute);
+		this.initializeDefaultAttributeOverrides(resourcePersistentAttribute);
 		this.embeddable = embeddableFor(persistentAttribute());
 	}
 	
-	protected void initializeAttributeOverrides(JavaResourcePersistentAttribute persistentAttributeResource) {
-		ListIterator<JavaResourceNode> annotations = persistentAttributeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverrides.ANNOTATION_NAME);
+	protected void initializeAttributeOverrides(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		ListIterator<JavaResourceNode> annotations = resourcePersistentAttribute.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverrides.ANNOTATION_NAME);
 		
 		while(annotations.hasNext()) {
 			JavaAttributeOverride attributeOverride = jpaFactory().buildJavaAttributeOverride(this, this);
@@ -231,26 +231,26 @@ public class GenericJavaEmbeddedIdMapping extends AbstractJavaAttributeMapping
 		}
 	}
 	
-	protected void initializeDefaultAttributeOverrides(JavaResourcePersistentAttribute persistentAttributeResource) {
+	protected void initializeDefaultAttributeOverrides(JavaResourcePersistentAttribute resourcePersistentAttribute) {
 		for (Iterator<String> i = allOverridableAttributeNames(); i.hasNext(); ) {
 			String attributeName = i.next();
 			JavaAttributeOverride attributeOverride = attributeOverrideNamed(attributeName);
 			if (attributeOverride == null) {
-				attributeOverride = createAttributeOverride(new NullAttributeOverride(persistentAttributeResource, attributeName));
+				attributeOverride = createAttributeOverride(new NullAttributeOverride(resourcePersistentAttribute, attributeName));
 				this.defaultAttributeOverrides.add(attributeOverride);
 			}
 		}
 	}	@Override
-	public void update(JavaResourcePersistentAttribute persistentAttributeResource) {
-		super.update(persistentAttributeResource);
+	public void update(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		super.update(resourcePersistentAttribute);
 		this.embeddable = embeddableFor(persistentAttribute());
-		this.updateSpecifiedAttributeOverrides(persistentAttributeResource);
-		this.updateDefaultAttributeOverrides(persistentAttributeResource);
+		this.updateSpecifiedAttributeOverrides(resourcePersistentAttribute);
+		this.updateDefaultAttributeOverrides(resourcePersistentAttribute);
 		
 	}
-	protected void updateSpecifiedAttributeOverrides(JavaResourcePersistentAttribute persistentAttributeResource) {
+	protected void updateSpecifiedAttributeOverrides(JavaResourcePersistentAttribute resourcePersistentAttribute) {
 		ListIterator<JavaAttributeOverride> attributeOverrides = specifiedAttributeOverrides();
-		ListIterator<JavaResourceNode> resourceAttributeOverrides = persistentAttributeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverrides.ANNOTATION_NAME);
+		ListIterator<JavaResourceNode> resourceAttributeOverrides = resourcePersistentAttribute.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverrides.ANNOTATION_NAME);
 		
 		while (attributeOverrides.hasNext()) {
 			JavaAttributeOverride attributeOverride = attributeOverrides.next();
@@ -273,16 +273,16 @@ public class GenericJavaEmbeddedIdMapping extends AbstractJavaAttributeMapping
 		return attributeOverride;
 	}
 	
-	protected void updateDefaultAttributeOverrides(JavaResourcePersistentAttribute persistentAttributeResource) {
+	protected void updateDefaultAttributeOverrides(JavaResourcePersistentAttribute resourcePersistentAttribute) {
 		for (Iterator<String> i = allOverridableAttributeNames(); i.hasNext(); ) {
 			String attributeName = i.next();
 			JavaAttributeOverride attributeOverride = attributeOverrideNamed(attributeName);
 			if (attributeOverride == null) {
-				attributeOverride = createAttributeOverride(new NullAttributeOverride(persistentAttributeResource, attributeName));
+				attributeOverride = createAttributeOverride(new NullAttributeOverride(resourcePersistentAttribute, attributeName));
 				addDefaultAttributeOverride(attributeOverride);
 			}
 			else if (attributeOverride.isVirtual()) {
-				attributeOverride.getColumn().update(new NullColumn(persistentAttributeResource));
+				attributeOverride.getColumn().update(new NullColumn(resourcePersistentAttribute));
 			}
 		}
 		
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaEmbeddedMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaEmbeddedMapping.java
index 969b002908..8a5a70bb4f 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaEmbeddedMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaEmbeddedMapping.java
@@ -44,7 +44,7 @@ import org.eclipse.jpt.utility.internal.iterators.TransformationIterator;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
 
-public class GenericJavaEmbeddedMapping extends AbstractJavaAttributeMapping implements JavaEmbeddedMapping
+public class GenericJavaEmbeddedMapping extends AbstractJavaAttributeMapping<Embedded> implements JavaEmbeddedMapping
 {
 	protected final List<JavaAttributeOverride> specifiedAttributeOverrides;
 
@@ -59,15 +59,15 @@ public class GenericJavaEmbeddedMapping extends AbstractJavaAttributeMapping imp
 	}
 	
 	@Override
-	public void initializeFromResource(JavaResourcePersistentAttribute persistentAttributeResource) {
-		super.initializeFromResource(persistentAttributeResource);
+	public void initializeFromResource(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		super.initializeFromResource(resourcePersistentAttribute);
 		this.embeddable = embeddableFor(persistentAttribute());
-		this.initializeSpecifiedAttributeOverrides(persistentAttributeResource);
-		this.initializeDefaultAttributeOverrides(persistentAttributeResource);
+		this.initializeSpecifiedAttributeOverrides(resourcePersistentAttribute);
+		this.initializeDefaultAttributeOverrides(resourcePersistentAttribute);
 	}
 	
-	protected void initializeSpecifiedAttributeOverrides(JavaResourcePersistentAttribute persistentAttributeResource) {
-		ListIterator<JavaResourceNode> annotations = persistentAttributeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverrides.ANNOTATION_NAME);
+	protected void initializeSpecifiedAttributeOverrides(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		ListIterator<JavaResourceNode> annotations = resourcePersistentAttribute.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverrides.ANNOTATION_NAME);
 		
 		while(annotations.hasNext()) {
 			JavaAttributeOverride attributeOverride = jpaFactory().buildJavaAttributeOverride(this, this);
@@ -76,12 +76,12 @@ public class GenericJavaEmbeddedMapping extends AbstractJavaAttributeMapping imp
 		}
 	}
 	
-	protected void initializeDefaultAttributeOverrides(JavaResourcePersistentAttribute persistentAttributeResource) {
+	protected void initializeDefaultAttributeOverrides(JavaResourcePersistentAttribute resourcePersistentAttribute) {
 		for (Iterator<String> i = allOverridableAttributeNames(); i.hasNext(); ) {
 			String attributeName = i.next();
 			JavaAttributeOverride attributeOverride = attributeOverrideNamed(attributeName);
 			if (attributeOverride == null) {
-				attributeOverride = createAttributeOverride(new NullAttributeOverride(persistentAttributeResource, attributeName));
+				attributeOverride = createAttributeOverride(new NullAttributeOverride(resourcePersistentAttribute, attributeName));
 				this.defaultAttributeOverrides.add(attributeOverride);
 			}
 		}
@@ -110,12 +110,7 @@ public class GenericJavaEmbeddedMapping extends AbstractJavaAttributeMapping imp
 			JPA.ATTRIBUTE_OVERRIDE,
 			JPA.ATTRIBUTE_OVERRIDES);
 	}
-	
-	@Override
-	protected Embedded mappingResource() {
-		return (Embedded) this.persistentAttributeResource.nonNullMappingAnnotation(annotationName());
-	}
-	
+
 	//****************** IEmbeddedMapping implemenation *******************
 
 	@SuppressWarnings("unchecked")
@@ -146,7 +141,7 @@ public class GenericJavaEmbeddedMapping extends AbstractJavaAttributeMapping imp
 	public JavaAttributeOverride addSpecifiedAttributeOverride(int index) {
 		JavaAttributeOverride attributeOverride = jpaFactory().buildJavaAttributeOverride(this, this);
 		this.specifiedAttributeOverrides.add(index, attributeOverride);
-		AttributeOverrideAnnotation attributeOverrideResource = (AttributeOverrideAnnotation) this.persistentAttributeResource.addAnnotation(index, AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverrides.ANNOTATION_NAME);
+		AttributeOverrideAnnotation attributeOverrideResource = (AttributeOverrideAnnotation) getResourcePersistentAttribute().addAnnotation(index, AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverrides.ANNOTATION_NAME);
 		attributeOverride.initializeFromResource(attributeOverrideResource);
 		this.fireItemAdded(EmbeddedMapping.SPECIFIED_ATTRIBUTE_OVERRIDES_LIST, index, attributeOverride);
 		return attributeOverride;
@@ -169,12 +164,12 @@ public class GenericJavaEmbeddedMapping extends AbstractJavaAttributeMapping imp
 		JavaAttributeOverride defaultAttributeOverride = null;
 		if (removedAttributeOverride.getName() != null) {
 			if (CollectionTools.contains(allOverridableAttributeNames(), removedAttributeOverride.getName())) {
-				defaultAttributeOverride = createAttributeOverride(new NullAttributeOverride(this.persistentAttributeResource, removedAttributeOverride.getName()));
+				defaultAttributeOverride = createAttributeOverride(new NullAttributeOverride(getResourcePersistentAttribute(), removedAttributeOverride.getName()));
 				this.defaultAttributeOverrides.add(defaultAttributeOverride);
 			}
 		}
 
-		this.persistentAttributeResource.removeAnnotation(index, AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverrides.ANNOTATION_NAME);
+		getResourcePersistentAttribute().removeAnnotation(index, AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverrides.ANNOTATION_NAME);
 		fireItemRemoved(EmbeddedMapping.SPECIFIED_ATTRIBUTE_OVERRIDES_LIST, index, removedAttributeOverride);
 		
 		if (defaultAttributeOverride != null) {
@@ -188,7 +183,7 @@ public class GenericJavaEmbeddedMapping extends AbstractJavaAttributeMapping imp
 
 	public void moveSpecifiedAttributeOverride(int targetIndex, int sourceIndex) {
 		CollectionTools.move(this.specifiedAttributeOverrides, targetIndex, sourceIndex);
-		this.persistentAttributeResource.move(targetIndex, sourceIndex, AttributeOverrides.ANNOTATION_NAME);
+		getResourcePersistentAttribute().move(targetIndex, sourceIndex, AttributeOverrides.ANNOTATION_NAME);
 		fireItemMoved(EmbeddedMapping.SPECIFIED_ATTRIBUTE_OVERRIDES_LIST, targetIndex, sourceIndex);		
 	}
 	
@@ -238,16 +233,16 @@ public class GenericJavaEmbeddedMapping extends AbstractJavaAttributeMapping imp
 	}
 
 	@Override
-	public void update(JavaResourcePersistentAttribute persistentAttributeResource) {
-		super.update(persistentAttributeResource);
+	public void update(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		super.update(resourcePersistentAttribute);
 		this.embeddable = embeddableFor(persistentAttribute());
-		this.updateSpecifiedAttributeOverrides(persistentAttributeResource);
-		this.updateDefaultAttributeOverrides(persistentAttributeResource);
+		this.updateSpecifiedAttributeOverrides(resourcePersistentAttribute);
+		this.updateDefaultAttributeOverrides(resourcePersistentAttribute);
 		
 	}
-	protected void updateSpecifiedAttributeOverrides(JavaResourcePersistentAttribute persistentAttributeResource) {
+	protected void updateSpecifiedAttributeOverrides(JavaResourcePersistentAttribute resourcePersistentAttribute) {
 		ListIterator<JavaAttributeOverride> attributeOverrides = specifiedAttributeOverrides();
-		ListIterator<JavaResourceNode> resourceAttributeOverrides = persistentAttributeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverrides.ANNOTATION_NAME);
+		ListIterator<JavaResourceNode> resourceAttributeOverrides = resourcePersistentAttribute.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverrides.ANNOTATION_NAME);
 		
 		while (attributeOverrides.hasNext()) {
 			JavaAttributeOverride attributeOverride = attributeOverrides.next();
@@ -270,16 +265,16 @@ public class GenericJavaEmbeddedMapping extends AbstractJavaAttributeMapping imp
 		return attributeOverride;
 	}
 	
-	protected void updateDefaultAttributeOverrides(JavaResourcePersistentAttribute persistentAttributeResource) {
+	protected void updateDefaultAttributeOverrides(JavaResourcePersistentAttribute resourcePersistentAttribute) {
 		for (Iterator<String> i = allOverridableAttributeNames(); i.hasNext(); ) {
 			String attributeName = i.next();
 			JavaAttributeOverride attributeOverride = attributeOverrideNamed(attributeName);
 			if (attributeOverride == null) {
-				attributeOverride = createAttributeOverride(new NullAttributeOverride(persistentAttributeResource, attributeName));
+				attributeOverride = createAttributeOverride(new NullAttributeOverride(resourcePersistentAttribute, attributeName));
 				addDefaultAttributeOverride(attributeOverride);
 			}
 			else if (attributeOverride.isVirtual()) {
-				attributeOverride.update(new NullAttributeOverride(persistentAttributeResource, attributeName));
+				attributeOverride.update(new NullAttributeOverride(resourcePersistentAttribute, attributeName));
 			}
 		}
 		
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaIdMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaIdMapping.java
index 542d2b9dd3..d0c1dd5a8c 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaIdMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaIdMapping.java
@@ -36,7 +36,7 @@ import org.eclipse.jpt.utility.internal.iterators.ArrayIterator;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
 
-public class GenericJavaIdMapping extends AbstractJavaAttributeMapping implements JavaIdMapping
+public class GenericJavaIdMapping extends AbstractJavaAttributeMapping<Id> implements JavaIdMapping
 {
 	protected final JavaColumn column;
 
@@ -58,34 +58,34 @@ public class GenericJavaIdMapping extends AbstractJavaAttributeMapping implement
 	}
 
 	@Override
-	public void initializeFromResource(JavaResourcePersistentAttribute persistentAttributeResource) {
-		super.initializeFromResource(persistentAttributeResource);
+	public void initializeFromResource(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		super.initializeFromResource(resourcePersistentAttribute);
 		this.column.initializeFromResource(this.columnResource());
 		this.temporal = this.temporal(this.temporalResource());
-		this.initializeTableGenerator(persistentAttributeResource);
-		this.initializeSequenceGenerator(persistentAttributeResource);
-		this.initializeGeneratedValue(persistentAttributeResource);
+		this.initializeTableGenerator(resourcePersistentAttribute);
+		this.initializeSequenceGenerator(resourcePersistentAttribute);
+		this.initializeGeneratedValue(resourcePersistentAttribute);
 		this.updatePersistenceUnitGenerators();
 	}
 	
-	protected void initializeTableGenerator(JavaResourcePersistentAttribute persistentAttributeResource) {
-		TableGeneratorAnnotation tableGeneratorResource = tableGenerator(persistentAttributeResource);
+	protected void initializeTableGenerator(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		TableGeneratorAnnotation tableGeneratorResource = tableGenerator(resourcePersistentAttribute);
 		if (tableGeneratorResource != null) {
 			this.tableGenerator = jpaFactory().buildJavaTableGenerator(this);
 			this.tableGenerator.initializeFromResource(tableGeneratorResource);
 		}
 	}
 	
-	protected void initializeSequenceGenerator(JavaResourcePersistentAttribute persistentAttributeResource) {
-		SequenceGeneratorAnnotation sequenceGeneratorResource = sequenceGenerator(persistentAttributeResource);
+	protected void initializeSequenceGenerator(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		SequenceGeneratorAnnotation sequenceGeneratorResource = sequenceGenerator(resourcePersistentAttribute);
 		if (sequenceGeneratorResource != null) {
 			this.sequenceGenerator = jpaFactory().buildJavaSequenceGenerator(this);
 			this.sequenceGenerator.initializeFromResource(sequenceGeneratorResource);
 		}
 	}
 	
-	protected void initializeGeneratedValue(JavaResourcePersistentAttribute persistentAttributeResource) {
-		GeneratedValueAnnotation generatedValueResource = generatedValue(persistentAttributeResource);
+	protected void initializeGeneratedValue(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		GeneratedValueAnnotation generatedValueResource = generatedValue(resourcePersistentAttribute);
 		if (generatedValueResource != null) {
 			this.generatedValue = jpaFactory().buildJavaGeneratedValue(this);
 			this.generatedValue.initializeFromResource(generatedValueResource);
@@ -93,11 +93,11 @@ public class GenericJavaIdMapping extends AbstractJavaAttributeMapping implement
 	}
 	
 	protected Temporal temporalResource() {
-		return (Temporal) this.persistentAttributeResource.nonNullAnnotation(Temporal.ANNOTATION_NAME);
+		return (Temporal) getResourcePersistentAttribute().nonNullAnnotation(Temporal.ANNOTATION_NAME);
 	}
 	
 	public ColumnAnnotation columnResource() {
-		return (ColumnAnnotation) this.persistentAttributeResource.nonNullAnnotation(ColumnAnnotation.ANNOTATION_NAME);
+		return (ColumnAnnotation) getResourcePersistentAttribute().nonNullAnnotation(ColumnAnnotation.ANNOTATION_NAME);
 	}
 
 	//************** IJavaAttributeMapping implementation ***************
@@ -161,7 +161,7 @@ public class GenericJavaIdMapping extends AbstractJavaAttributeMapping implement
 			throw new IllegalStateException("gemeratedValue already exists");
 		}
 		this.generatedValue = jpaFactory().buildJavaGeneratedValue(this);
-		GeneratedValueAnnotation generatedValueResource = (GeneratedValueAnnotation) this.persistentAttributeResource.addAnnotation(GeneratedValueAnnotation.ANNOTATION_NAME);
+		GeneratedValueAnnotation generatedValueResource = (GeneratedValueAnnotation) getResourcePersistentAttribute().addAnnotation(GeneratedValueAnnotation.ANNOTATION_NAME);
 		this.generatedValue.initializeFromResource(generatedValueResource);
 		firePropertyChanged(GENERATED_VALUE_PROPERTY, null, this.generatedValue);
 		return this.generatedValue;
@@ -173,7 +173,7 @@ public class GenericJavaIdMapping extends AbstractJavaAttributeMapping implement
 		}
 		JavaGeneratedValue oldGeneratedValue = this.generatedValue;
 		this.generatedValue = null;
-		this.persistentAttributeResource.removeAnnotation(GeneratedValueAnnotation.ANNOTATION_NAME);
+		getResourcePersistentAttribute().removeAnnotation(GeneratedValueAnnotation.ANNOTATION_NAME);
 		firePropertyChanged(GENERATED_VALUE_PROPERTY, oldGeneratedValue, null);
 	}
 	
@@ -192,7 +192,7 @@ public class GenericJavaIdMapping extends AbstractJavaAttributeMapping implement
 			throw new IllegalStateException("tableGenerator already exists");
 		}
 		this.tableGenerator = jpaFactory().buildJavaTableGenerator(this);
-		TableGeneratorAnnotation tableGeneratorResource = (TableGeneratorAnnotation) this.persistentAttributeResource.addAnnotation(TableGeneratorAnnotation.ANNOTATION_NAME);
+		TableGeneratorAnnotation tableGeneratorResource = (TableGeneratorAnnotation) getResourcePersistentAttribute().addAnnotation(TableGeneratorAnnotation.ANNOTATION_NAME);
 		this.tableGenerator.initializeFromResource(tableGeneratorResource);
 		firePropertyChanged(TABLE_GENERATOR_PROPERTY, null, this.tableGenerator);
 		return this.tableGenerator;
@@ -204,7 +204,7 @@ public class GenericJavaIdMapping extends AbstractJavaAttributeMapping implement
 		}
 		JavaTableGenerator oldTableGenerator = this.tableGenerator;
 		this.tableGenerator = null;
-		this.persistentAttributeResource.removeAnnotation(TableGeneratorAnnotation.ANNOTATION_NAME);
+		getResourcePersistentAttribute().removeAnnotation(TableGeneratorAnnotation.ANNOTATION_NAME);
 		firePropertyChanged(TABLE_GENERATOR_PROPERTY, oldTableGenerator, null);
 	}
 	
@@ -224,7 +224,7 @@ public class GenericJavaIdMapping extends AbstractJavaAttributeMapping implement
 		}
 		
 		this.sequenceGenerator = jpaFactory().buildJavaSequenceGenerator(this);
-		SequenceGeneratorAnnotation sequenceGeneratorResource = (SequenceGeneratorAnnotation) this.persistentAttributeResource.addAnnotation(SequenceGeneratorAnnotation.ANNOTATION_NAME);
+		SequenceGeneratorAnnotation sequenceGeneratorResource = (SequenceGeneratorAnnotation) getResourcePersistentAttribute().addAnnotation(SequenceGeneratorAnnotation.ANNOTATION_NAME);
 		this.sequenceGenerator.initializeFromResource(sequenceGeneratorResource);
 		firePropertyChanged(SEQUENCE_GENERATOR_PROPERTY, null, this.sequenceGenerator);
 		return this.sequenceGenerator;
@@ -236,7 +236,7 @@ public class GenericJavaIdMapping extends AbstractJavaAttributeMapping implement
 		}
 		JavaSequenceGenerator oldSequenceGenerator = this.sequenceGenerator;
 		this.sequenceGenerator = null;
-		this.persistentAttributeResource.removeAnnotation(SequenceGeneratorAnnotation.ANNOTATION_NAME);
+		getResourcePersistentAttribute().removeAnnotation(SequenceGeneratorAnnotation.ANNOTATION_NAME);
 		firePropertyChanged(SEQUENCE_GENERATOR_PROPERTY, oldSequenceGenerator, null);
 	}
 	
@@ -252,13 +252,13 @@ public class GenericJavaIdMapping extends AbstractJavaAttributeMapping implement
 
 	
 	@Override
-	public void update(JavaResourcePersistentAttribute persistentAttributeResource) {
-		super.update(persistentAttributeResource);
+	public void update(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		super.update(resourcePersistentAttribute);
 		this.column.update(this.columnResource());
 		this.setTemporal_(this.temporal(this.temporalResource()));
-		this.updateTableGenerator(persistentAttributeResource);
-		this.updateSequenceGenerator(persistentAttributeResource);
-		this.updateGeneratedValue(persistentAttributeResource);
+		this.updateTableGenerator(resourcePersistentAttribute);
+		this.updateSequenceGenerator(resourcePersistentAttribute);
+		this.updateGeneratedValue(resourcePersistentAttribute);
 		this.updatePersistenceUnitGenerators();
 	}
 	
@@ -266,8 +266,8 @@ public class GenericJavaIdMapping extends AbstractJavaAttributeMapping implement
 		return TemporalType.fromJavaResourceModel(temporal.getValue());
 	}
 
-	protected void updateTableGenerator(JavaResourcePersistentAttribute persistentAttributeResource) {
-		TableGeneratorAnnotation tableGeneratorResource = tableGenerator(persistentAttributeResource);
+	protected void updateTableGenerator(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		TableGeneratorAnnotation tableGeneratorResource = tableGenerator(resourcePersistentAttribute);
 		if (tableGeneratorResource == null) {
 			if (getTableGenerator() != null) {
 				setTableGenerator(null);
@@ -284,8 +284,8 @@ public class GenericJavaIdMapping extends AbstractJavaAttributeMapping implement
 		}
 	}
 	
-	protected void updateSequenceGenerator(JavaResourcePersistentAttribute persistentAttributeResource) {
-		SequenceGeneratorAnnotation sequenceGeneratorResource = sequenceGenerator(persistentAttributeResource);
+	protected void updateSequenceGenerator(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		SequenceGeneratorAnnotation sequenceGeneratorResource = sequenceGenerator(resourcePersistentAttribute);
 		if (sequenceGeneratorResource == null) {
 			if (getSequenceGenerator() != null) {
 				setSequenceGenerator(null);
@@ -302,8 +302,8 @@ public class GenericJavaIdMapping extends AbstractJavaAttributeMapping implement
 		}
 	}
 	
-	protected void updateGeneratedValue(JavaResourcePersistentAttribute persistentAttributeResource) {
-		GeneratedValueAnnotation generatedValueResource = generatedValue(persistentAttributeResource);
+	protected void updateGeneratedValue(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		GeneratedValueAnnotation generatedValueResource = generatedValue(resourcePersistentAttribute);
 		if (generatedValueResource == null) {
 			if (getGeneratedValue() != null) {
 				setGeneratedValue(null);
@@ -320,16 +320,16 @@ public class GenericJavaIdMapping extends AbstractJavaAttributeMapping implement
 		}
 	}
 	
-	protected TableGeneratorAnnotation tableGenerator(JavaResourcePersistentAttribute persistentAttributeResource) {
-		return (TableGeneratorAnnotation) persistentAttributeResource.annotation(TableGeneratorAnnotation.ANNOTATION_NAME);
+	protected TableGeneratorAnnotation tableGenerator(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		return (TableGeneratorAnnotation) resourcePersistentAttribute.annotation(TableGeneratorAnnotation.ANNOTATION_NAME);
 	}
 	
-	protected SequenceGeneratorAnnotation sequenceGenerator(JavaResourcePersistentAttribute persistentAttributeResource) {
-		return (SequenceGeneratorAnnotation) persistentAttributeResource.annotation(SequenceGeneratorAnnotation.ANNOTATION_NAME);
+	protected SequenceGeneratorAnnotation sequenceGenerator(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		return (SequenceGeneratorAnnotation) resourcePersistentAttribute.annotation(SequenceGeneratorAnnotation.ANNOTATION_NAME);
 	}
 	
-	protected GeneratedValueAnnotation generatedValue(JavaResourcePersistentAttribute persistentAttributeResource) {
-		return (GeneratedValueAnnotation) persistentAttributeResource.annotation(GeneratedValueAnnotation.ANNOTATION_NAME);
+	protected GeneratedValueAnnotation generatedValue(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		return (GeneratedValueAnnotation) resourcePersistentAttribute.annotation(GeneratedValueAnnotation.ANNOTATION_NAME);
 	}
 
 
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaManyToManyMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaManyToManyMapping.java
index edb79045f5..fa05f70a5c 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaManyToManyMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaManyToManyMapping.java
@@ -45,23 +45,18 @@ public class GenericJavaManyToManyMapping extends AbstractJavaMultiRelationshipM
 			JPA.MAP_KEY,
 			JPA.JOIN_TABLE);
 	}
-	
-	@Override
-	protected ManyToMany relationshipMapping() {
-		return (ManyToMany) this.persistentAttributeResource.mappingAnnotation();
-	}
-	
+		
 	// ********** JavaMultiRelationshipMapping implementation **********
 
 	@Override
 	protected boolean mappedByTouches(int pos, CompilationUnit astRoot) {
-		return this.relationshipMapping().mappedByTouches(pos, astRoot);
+		return this.mappingResource().mappedByTouches(pos, astRoot);
 	}
 	
 	
 	@Override
 	protected void setMappedByOnResourceModel(String mappedBy) {
-		relationshipMapping().setMappedBy(mappedBy);
+		mappingResource().setMappedBy(mappedBy);
 	}
 	
 	@Override
@@ -78,7 +73,7 @@ public class GenericJavaManyToManyMapping extends AbstractJavaMultiRelationshipM
 	
 	@Override
 	public TextRange mappedByTextRange(CompilationUnit astRoot) {
-		return this.relationshipMapping().mappedByTextRange(astRoot);
+		return this.mappingResource().mappedByTextRange(astRoot);
 	}
 	
 	@Override
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaManyToOneMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaManyToOneMapping.java
index 13e2081282..b30fbf733f 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaManyToOneMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaManyToOneMapping.java
@@ -46,18 +46,13 @@ public class GenericJavaManyToOneMapping extends AbstractJavaSingleRelationshipM
 	}
 	
 	@Override
-	protected ManyToOne relationshipMapping() {
-		return (ManyToOne) this.persistentAttributeResource.mappingAnnotation();
-	}
-	
-	@Override
 	public boolean isOverridableAssociationMapping() {
 		return true;
 	}
 	
 	@Override
 	protected void setOptionalOnResourceModel(Boolean newOptional) {
-		this.relationshipMapping().setOptional(newOptional);
+		this.mappingResource().setOptional(newOptional);
 	}
 	
 	@Override
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaNullAttributeMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaNullAttributeMapping.java
index 6d46be00d4..1f3903460f 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaNullAttributeMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaNullAttributeMapping.java
@@ -14,17 +14,18 @@ import java.util.List;
 import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.MappingKeys;
 import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;
+import org.eclipse.jpt.core.resource.java.JavaResourceNode;
 import org.eclipse.jpt.utility.internal.iterators.EmptyIterator;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
 
 
-public class GenericJavaNullAttributeMapping extends AbstractJavaAttributeMapping
+public class GenericJavaNullAttributeMapping extends AbstractJavaAttributeMapping<JavaResourceNode>
 {
 	public GenericJavaNullAttributeMapping(JavaPersistentAttribute parent) {
 		super(parent);
 	}
-
+	
 	public String getKey() {
 		return MappingKeys.NULL_ATTRIBUTE_MAPPING_KEY;
 	}
@@ -38,6 +39,11 @@ public class GenericJavaNullAttributeMapping extends AbstractJavaAttributeMappin
 	}
 	
 	@Override
+	protected JavaResourceNode mappingResource() {
+		return null;
+	}
+	
+	@Override
 	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
 		super.addToMessages(messages, astRoot);
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaOneToManyMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaOneToManyMapping.java
index 8f828a3ac1..e07f8c594a 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaOneToManyMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaOneToManyMapping.java
@@ -48,22 +48,17 @@ public class GenericJavaOneToManyMapping extends AbstractJavaMultiRelationshipMa
 	public String annotationName() {
 		return OneToMany.ANNOTATION_NAME;
 	}
-	
-	@Override
-	protected OneToMany relationshipMapping() {
-		return (OneToMany) this.persistentAttributeResource.mappingAnnotation();
-	}
 
 	// ********** JavaMultiRelationshipMapping implementation **********
 
 	@Override
 	protected boolean mappedByTouches(int pos, CompilationUnit astRoot) {
-		return this.relationshipMapping().mappedByTouches(pos, astRoot);
+		return this.mappingResource().mappedByTouches(pos, astRoot);
 	}
 
 	@Override
 	protected void setMappedByOnResourceModel(String mappedBy) {
-		this.relationshipMapping().setMappedBy(mappedBy);
+		this.mappingResource().setMappedBy(mappedBy);
 	}
 	
 	@Override
@@ -80,7 +75,7 @@ public class GenericJavaOneToManyMapping extends AbstractJavaMultiRelationshipMa
 
 	@Override
 	public TextRange mappedByTextRange(CompilationUnit astRoot) {
-		return this.relationshipMapping().mappedByTextRange(astRoot);
+		return this.mappingResource().mappedByTextRange(astRoot);
 	}
 	
 	@Override
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaOneToOneMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaOneToOneMapping.java
index fa632fd101..90e8483077 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaOneToOneMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaOneToOneMapping.java
@@ -55,11 +55,6 @@ public class GenericJavaOneToOneMapping extends AbstractJavaSingleRelationshipMa
 	public String getKey() {
 		return MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY;
 	}
-	
-	@Override
-	protected OneToOne relationshipMapping() {
-		return (OneToOne) this.persistentAttributeResource.mappingAnnotation();
-	}
 
 	public boolean isRelationshipOwner() {
 		return getMappedBy() == null;
@@ -72,7 +67,7 @@ public class GenericJavaOneToOneMapping extends AbstractJavaSingleRelationshipMa
 	public void setMappedBy(String newMappedBy) {
 		String oldMappedBy = this.mappedBy;
 		this.mappedBy = newMappedBy;
-		this.relationshipMapping().setMappedBy(newMappedBy);
+		this.mappingResource().setMappedBy(newMappedBy);
 		firePropertyChanged(NonOwningMapping.MAPPED_BY_PROPERTY, oldMappedBy, newMappedBy);
 	}
 
@@ -83,15 +78,15 @@ public class GenericJavaOneToOneMapping extends AbstractJavaSingleRelationshipMa
 
 	@Override
 	protected void setOptionalOnResourceModel(Boolean newOptional) {
-		this.relationshipMapping().setOptional(newOptional);
+		this.mappingResource().setOptional(newOptional);
 	}
 	
 	public TextRange mappedByTextRange(CompilationUnit astRoot) {
-		return this.relationshipMapping().mappedByTextRange(astRoot);
+		return this.mappingResource().mappedByTextRange(astRoot);
 	}
 
 	public boolean mappedByTouches(int pos, CompilationUnit astRoot) {
-		return this.relationshipMapping().mappedByTouches(pos, astRoot);
+		return this.mappingResource().mappedByTouches(pos, astRoot);
 	}
 
 	@Override
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaPersistentAttribute.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaPersistentAttribute.java
index 04a490b6f7..429fe947e2 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaPersistentAttribute.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaPersistentAttribute.java
@@ -37,7 +37,7 @@ public class GenericJavaPersistentAttribute extends AbstractJavaJpaContextNode
 
 	protected JavaAttributeMapping specifiedMapping;
 
-	protected JavaResourcePersistentAttribute persistentAttributeResource;
+	protected JavaResourcePersistentAttribute resourcePersistentAttribute;
 
 	public GenericJavaPersistentAttribute(JavaPersistentType parent) {
 		super(parent);
@@ -48,14 +48,15 @@ public class GenericJavaPersistentAttribute extends AbstractJavaJpaContextNode
 	}
 
 	public void initializeFromResource(JavaResourcePersistentAttribute persistentAttributeResource) {
-		this.persistentAttributeResource = persistentAttributeResource;
+		this.resourcePersistentAttribute = persistentAttributeResource;
 		this.name = this.name(persistentAttributeResource);
 		initializeDefaultMapping(persistentAttributeResource);
 		initializeSpecifiedMapping(persistentAttributeResource);
 	}
 	
 	protected void initializeDefaultMapping(JavaResourcePersistentAttribute persistentAttributeResource) {
-		this.defaultMapping = createDefaultJavaAttributeMapping(persistentAttributeResource);
+		this.defaultMapping = jpaPlatform().buildDefaultJavaAttributeMapping(this);
+		this.defaultMapping.initializeFromResource(persistentAttributeResource);
 	}
 
 	protected void initializeSpecifiedMapping(JavaResourcePersistentAttribute persistentAttributeResource) {
@@ -64,7 +65,7 @@ public class GenericJavaPersistentAttribute extends AbstractJavaJpaContextNode
 	}
 	
 	public JavaResourcePersistentAttribute getResourcePersistentAttribute() {
-		return this.persistentAttributeResource;
+		return this.resourcePersistentAttribute;
 	}
 	
 	public JavaPersistentType persistentType() {
@@ -167,10 +168,10 @@ public class GenericJavaPersistentAttribute extends AbstractJavaJpaContextNode
 
 		this.specifiedMapping = newMapping;	
 		if (newMapping != null) {
-			this.persistentAttributeResource.setMappingAnnotation(newMapping.annotationName());
+			this.resourcePersistentAttribute.setMappingAnnotation(newMapping.annotationName());
 		}
 		else {
-			this.persistentAttributeResource.setMappingAnnotation(null);			
+			this.resourcePersistentAttribute.setMappingAnnotation(null);			
 		}
 		firePropertyChanged(PersistentAttribute.SPECIFIED_MAPPING_PROPERTY, oldMapping, newMapping);
 		
@@ -181,7 +182,7 @@ public class GenericJavaPersistentAttribute extends AbstractJavaJpaContextNode
 			}
 			
 			for (String annotationName : annotationsToRemove) {
-				this.persistentAttributeResource.removeAnnotation(annotationName);
+				this.resourcePersistentAttribute.removeAnnotation(annotationName);
 			}
 		}
 	}
@@ -206,7 +207,7 @@ public class GenericJavaPersistentAttribute extends AbstractJavaJpaContextNode
 
 
 	public TextRange fullTextRange(CompilationUnit astRoot) {
-		return this.persistentAttributeResource.textRange(astRoot);
+		return this.resourcePersistentAttribute.textRange(astRoot);
 	}
 
 	public TextRange validationTextRange(CompilationUnit astRoot) {
@@ -214,53 +215,56 @@ public class GenericJavaPersistentAttribute extends AbstractJavaJpaContextNode
 	}
 
 	public TextRange selectionTextRange(CompilationUnit astRoot) {
-		return this.persistentAttributeResource.nameTextRange(astRoot);
+		return this.resourcePersistentAttribute.nameTextRange(astRoot);
 	}
 	
 	public TextRange selectionTextRange() {
-		return selectionTextRange(this.persistentAttributeResource.getMember().astRoot());
+		return selectionTextRange(this.resourcePersistentAttribute.getMember().astRoot());
 	}
 	
 
-	public void update(JavaResourcePersistentAttribute persistentAttributeResource) {
-		this.persistentAttributeResource = persistentAttributeResource;
-		this.setName(this.name(persistentAttributeResource));
-		this.updateDefaultMapping(persistentAttributeResource);
-		this.updateSpecifiedMapping(persistentAttributeResource);
+	public void update(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		this.resourcePersistentAttribute = resourcePersistentAttribute;
+		this.setName(this.name(resourcePersistentAttribute));
+		this.updateDefaultMapping(resourcePersistentAttribute);
+		this.updateSpecifiedMapping(resourcePersistentAttribute);
 	}
 	
-	protected String name(JavaResourcePersistentAttribute persistentAttributeResource) {
-		return persistentAttributeResource.getName();	
+	protected String name(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		return resourcePersistentAttribute.getName();	
 	}
 	
 	public String specifiedMappingAnnotationName() {
 		return (this.specifiedMapping == null) ? null : this.specifiedMapping.annotationName();
 	}
 	
-	protected void updateSpecifiedMapping(JavaResourcePersistentAttribute persistentAttributeResource) {
-		String javaMappingAnnotationName = this.javaMappingAnnotationName(persistentAttributeResource);
+	protected void updateSpecifiedMapping(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		String javaMappingAnnotationName = this.javaMappingAnnotationName(resourcePersistentAttribute);
 		if (specifiedMappingAnnotationName() != javaMappingAnnotationName) {
-			setSpecifiedMapping(createJavaAttributeMappingFromAnnotation(javaMappingAnnotationName, persistentAttributeResource));
+			setSpecifiedMapping(createJavaAttributeMappingFromAnnotation(javaMappingAnnotationName, resourcePersistentAttribute));
 		}
 		else {
 			if (getSpecifiedMapping() != null) {
-				getSpecifiedMapping().update(persistentAttributeResource);
+				getSpecifiedMapping().update(resourcePersistentAttribute);
 			}
 		}
 	}
 	
-	protected void updateDefaultMapping(JavaResourcePersistentAttribute persistentAttributeResource) {
+	protected void updateDefaultMapping(JavaResourcePersistentAttribute resourcePersistentAttribute) {
 		String defaultMappingKey = jpaPlatform().defaultJavaAttributeMappingKey(this);
 		if (getDefaultMapping().getKey() != defaultMappingKey) {
-			setDefaultMapping(createDefaultJavaAttributeMapping(persistentAttributeResource));
+			JavaAttributeMapping oldDefaultMapping = this.defaultMapping;
+			this.defaultMapping = jpaPlatform().buildDefaultJavaAttributeMapping(this);
+			this.defaultMapping.initializeFromResource(resourcePersistentAttribute);
+			firePropertyChanged(PersistentAttribute.DEFAULT_MAPPING_PROPERTY, oldDefaultMapping, this.defaultMapping);
 		}
 		else {
-			getDefaultMapping().update(persistentAttributeResource);
+			getDefaultMapping().update(resourcePersistentAttribute);
 		}
 	}
 	
-	protected String javaMappingAnnotationName(JavaResourcePersistentAttribute persistentAttributeResource) {
-		Annotation mappingAnnotation = (Annotation) persistentAttributeResource.mappingAnnotation();
+	protected String javaMappingAnnotationName(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		Annotation mappingAnnotation = (Annotation) resourcePersistentAttribute.mappingAnnotation();
 		if (mappingAnnotation != null) {
 			return mappingAnnotation.getAnnotationName();
 		}
@@ -274,26 +278,20 @@ public class GenericJavaPersistentAttribute extends AbstractJavaJpaContextNode
 		return jpaPlatform().buildJavaAttributeMappingFromMappingKey(key, this);
 	}
 
-	protected JavaAttributeMapping createJavaAttributeMappingFromAnnotation(String annotationName, JavaResourcePersistentAttribute persistentAttributeResource) {
+	protected JavaAttributeMapping createJavaAttributeMappingFromAnnotation(String annotationName, JavaResourcePersistentAttribute resourcePersistentAttribute) {
 		if (annotationName == null) {
 			return null;
 		}
 		JavaAttributeMapping mapping = jpaPlatform().buildJavaAttributeMappingFromAnnotation(annotationName, this);
-		mapping.initializeFromResource(persistentAttributeResource);
+		mapping.initializeFromResource(resourcePersistentAttribute);
 		return mapping;
 	}
 
-	protected JavaAttributeMapping createDefaultJavaAttributeMapping(JavaResourcePersistentAttribute persistentAttributeResource) {		
-		JavaAttributeMapping defaultMapping = jpaPlatform().buildDefaultJavaAttributeMapping(this);
-		defaultMapping.initializeFromResource(persistentAttributeResource);
-		return defaultMapping;
-	}
-
 	/**
 	 * the mapping might be "default", but it still might be a "null" mapping...
 	 */
-	public boolean mappingIsDefault() {
-		return this.specifiedMapping == null;
+	public boolean mappingIsDefault(JavaAttributeMapping mapping) {
+		return this.defaultMapping == mapping;
 	}
 
 	@Override
@@ -317,7 +315,6 @@ public class GenericJavaPersistentAttribute extends AbstractJavaJpaContextNode
 		else if (this.defaultMapping != null) {
 			this.defaultMapping.addToMessages(messages, astRoot);
 		}
-		
 	}
 	
 	@Override
@@ -325,5 +322,4 @@ public class GenericJavaPersistentAttribute extends AbstractJavaJpaContextNode
 		super.toString(sb);
 		sb.append(getName());
 	}
-	
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaTransientMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaTransientMapping.java
index 0920211a59..b56ae82856 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaTransientMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaTransientMapping.java
@@ -20,7 +20,7 @@ import org.eclipse.jpt.utility.internal.iterators.EmptyIterator;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
 
-public class GenericJavaTransientMapping extends AbstractJavaAttributeMapping
+public class GenericJavaTransientMapping extends AbstractJavaAttributeMapping<Transient>
 	implements JavaTransientMapping
 {
 	public GenericJavaTransientMapping(JavaPersistentAttribute parent) {
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaVersionMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaVersionMapping.java
index 48dce5e5c0..de0c039ed4 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaVersionMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaVersionMapping.java
@@ -30,7 +30,7 @@ import org.eclipse.jpt.utility.internal.iterators.ArrayIterator;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
 
-public class GenericJavaVersionMapping extends AbstractJavaAttributeMapping implements JavaVersionMapping
+public class GenericJavaVersionMapping extends AbstractJavaAttributeMapping<Version> implements JavaVersionMapping
 {
 	protected final JavaColumn column;
 	
@@ -46,18 +46,18 @@ public class GenericJavaVersionMapping extends AbstractJavaAttributeMapping impl
 	}
 	
 	@Override
-	public void initializeFromResource(JavaResourcePersistentAttribute persistentAttributeResource) {
-		super.initializeFromResource(persistentAttributeResource);
+	public void initializeFromResource(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		super.initializeFromResource(resourcePersistentAttribute);
 		this.column.initializeFromResource(this.columnResource());
 		this.temporal = this.temporal(this.temporalResource());
 	}
 	
 	protected Temporal temporalResource() {
-		return (Temporal) this.persistentAttributeResource.nonNullAnnotation(Temporal.ANNOTATION_NAME);
+		return (Temporal) getResourcePersistentAttribute().nonNullAnnotation(Temporal.ANNOTATION_NAME);
 	}
 	
 	public ColumnAnnotation columnResource() {
-		return (ColumnAnnotation) this.persistentAttributeResource.nonNullAnnotation(ColumnAnnotation.ANNOTATION_NAME);
+		return (ColumnAnnotation) getResourcePersistentAttribute().nonNullAnnotation(ColumnAnnotation.ANNOTATION_NAME);
 	}
 
 	//************** IJavaAttributeMapping implementation ***************
@@ -104,8 +104,8 @@ public class GenericJavaVersionMapping extends AbstractJavaAttributeMapping impl
 	}
 
 	@Override
-	public void update(JavaResourcePersistentAttribute persistentAttributeResource) {
-		super.update(persistentAttributeResource);
+	public void update(JavaResourcePersistentAttribute resourcePersistentAttribute) {
+		super.update(resourcePersistentAttribute);
 		this.column.update(this.columnResource());
 		this.setTemporal(this.temporal(this.temporalResource()));
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/resource/java/AbstractJavaResourcePersistentMember.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/resource/java/AbstractJavaResourcePersistentMember.java
index 92be4a2094..98f2911f70 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/resource/java/AbstractJavaResourcePersistentMember.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/resource/java/AbstractJavaResourcePersistentMember.java
@@ -159,14 +159,10 @@ public abstract class AbstractJavaResourcePersistentMember<E extends Member>
 		return null;
 	}
 
-	public JavaResourceNode nonNullMappingAnnotation(String annotationName) {
-		Annotation annotation = mappingAnnotation(annotationName);
-		if (annotation == null) {
-			return buildNullMappingAnnotation(annotationName);	
-		}
-		return annotation;
+	public JavaResourceNode nullMappingAnnotation(String annotationName) {
+		return buildNullMappingAnnotation(annotationName);	
 	}
-
+	
 	@SuppressWarnings("unchecked")
 	public Iterator<Annotation> annotations() {
 		return new CloneIterator<Annotation>(this.annotations);
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/java/JavaResourcePersistentMember.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/java/JavaResourcePersistentMember.java
index f45433b6f2..ac7c407960 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/java/JavaResourcePersistentMember.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/java/JavaResourcePersistentMember.java
@@ -107,13 +107,13 @@ public interface JavaResourcePersistentMember extends JavaResourceNode
 	JavaResourceNode nonNullAnnotation(String annotationName);
 
 	/**
-	 * Returns the <code>JavaResource</code> with this fully qualifed annotation name. 
-	 * Return the first if there are duplicates in the source code.  Will not return null,
-	 * but a null Object instead if no annotation with this name exists in the java source.
+	 * Return a null implementation of <code>JavaResourceNode</code> with this fully qualifed annotation name.
+	 * The corresponding AnnotationDefinition needs to implement buildNullAnnotation()
+	 * {@link AnnotationDefinition#buildNullAnnotation(JavaResourcePersistentMember, org.eclipse.jpt.core.internal.jdtutility.Member)}
 	 * @param annotationName
 	 * @return
 	 */
-	JavaResourceNode nonNullMappingAnnotation(String annotationName);
+	JavaResourceNode nullMappingAnnotation(String annotationName);
 
 	/**
 	 * Add an annotation for the given fully qualified annotation name