reworked validation

83 files changed, 1804 insertions, 1690 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 2475db24c4..eeced7b6d3 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
@@ -135,14 +135,6 @@ public interface JpaPlatform
 	String getDefaultJavaAttributeMappingKey(JavaPersistentAttribute persistentAttribute);
 
 
-	// ************** Validation ***********************************************************
-	
-	/**
-	 * Adds validation messages to the growing list of messages for a given project
-	 */
-	void addToMessages(JpaProject project, List<IMessage> messages);
-	
-
 	// ************* Database ************************************************************
 	
 	/**
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/JpaProject.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/JpaProject.java
index 1017becf86..028ac453ca 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/JpaProject.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/JpaProject.java
@@ -10,7 +10,6 @@
 package org.eclipse.jpt.core;
 
 import java.util.Iterator;
-import java.util.List;
 
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IProject;
@@ -230,7 +229,7 @@ public interface JpaProject extends JpaNode {
 	/**
 	 * Return the {@link JpaRootContextNode} representing the JPA content of this project
 	 */
-	JpaRootContextNode getRootContext();
+	JpaRootContextNode getRootContextNode();
 	
 	/**
 	 * Return the names of the JPA project's annotated classes.
@@ -271,11 +270,6 @@ public interface JpaProject extends JpaNode {
 	 */
 	Iterator<IMessage> validationMessages();
 
-	/**
-	 * Add to the list of current validation messages
-	 */
-	void addToMessages(List<IMessage> messages);
-
 
 	// **************** support for modifying shared documents *****************
 
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/JpaRootContextNode.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/JpaRootContextNode.java
index fa73eef97f..925ff20573 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/JpaRootContextNode.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/JpaRootContextNode.java
@@ -28,7 +28,7 @@ public interface JpaRootContextNode extends JpaContextNode
 	/**
 	 * String constant associated with changes to the persistenceXml property
 	 */
-	public final static String PERSISTENCE_XML_PROPERTY = "persistenceXml";
+	public final static String PERSISTENCE_XML_PROPERTY = "persistenceXml"; //$NON-NLS-1$
 	
 	/** 
 	 * Return the content represented by the persistence.xml file associated with 
@@ -62,8 +62,8 @@ public interface JpaRootContextNode extends JpaContextNode
 	// **************** validation *********************************************
 	
 	/**
-	 * All subclass implementations {@link #addToMessages(List<IMessage>)} 
-	 * should be preceded by a "super" call to this method
+	 * Add validation messages to the specified list.
 	 */
-	public void addToMessages(List<IMessage> messages);
+	public void validate(List<IMessage> messages);
+
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/MultiRelationshipMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/MultiRelationshipMapping.java
index dd1141aff4..624452c45c 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/MultiRelationshipMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/MultiRelationshipMapping.java
@@ -26,30 +26,30 @@ public interface MultiRelationshipMapping extends NonOwningMapping
 
 	String getOrderBy();
 	void setOrderBy(String value);
-		String ORDER_BY_PROPERTY = "orderByProperty";
+		String ORDER_BY_PROPERTY = "orderBy"; //$NON-NLS-1$
 
 
 	boolean isNoOrdering();
 	void setNoOrdering(boolean newNoOrdering);
-		String NO_ORDERING_PROPERTY = "noOrderingProperty";
+		String NO_ORDERING_PROPERTY = "noOrdering"; //$NON-NLS-1$
 
 	boolean isPkOrdering();
 	void setPkOrdering(boolean newPkOrdering);
-	String PK_ORDERING_PROPERTY = "pkOrderingProperty";
+	String PK_ORDERING_PROPERTY = "pkOrdering"; //$NON-NLS-1$
 
 	boolean isCustomOrdering();
 	void setCustomOrdering(boolean newCustomOrdering);
-	String CUSTOM_ORDERING_PROPERTY = "customOrderingProperty";
+	String CUSTOM_ORDERING_PROPERTY = "customOrdering"; //$NON-NLS-1$
 
 	
 	JoinTable getJoinTable();
 	
-	boolean isJoinTableSpecified();
+	boolean joinTableIsSpecified();
 
 
 	String getMapKey();
 	void setMapKey(String value);
-		String MAP_KEY_PROPERTY = "mapKeyProperty";
+		String MAP_KEY_PROPERTY = "mapKey"; //$NON-NLS-1$
 
 	Iterator<String> candidateMapKeyNames();
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/PersistentType.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/PersistentType.java
index 1df249be21..e6515a0d1c 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/PersistentType.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/PersistentType.java
@@ -112,6 +112,6 @@ public interface PersistentType extends JpaContextNode, JpaStructureNode
 	/**
 	 * Add to the list of current validation messages
 	 */
-	void addToMessages(List<IMessage> messages);
+	void validate(List<IMessage> messages);
 
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaJpaContextNode.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaJpaContextNode.java
index 03012331ca..53faac070e 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaJpaContextNode.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaJpaContextNode.java
@@ -41,7 +41,7 @@ public interface JavaJpaContextNode extends JpaContextNode
 	/**
 	 * Adds to the list of current validation messages
 	 */
-	void addToMessages(List<IMessage> messages, CompilationUnit astRoot);
+	void validate(List<IMessage> messages, CompilationUnit astRoot);
 
 	TextRange getValidationTextRange(CompilationUnit astRoot);
 
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/OrmAttributeMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/OrmAttributeMapping.java
index 25f10c5b20..f4fc3bd7c5 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/OrmAttributeMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/OrmAttributeMapping.java
@@ -30,11 +30,11 @@ public interface OrmAttributeMapping extends AttributeMapping, OrmJpaContextNode
 
 	String getName();
 	void setName(String newName);
-	String NAME_PROPERTY = "nameProperty";
+	String NAME_PROPERTY = "name"; //$NON-NLS-1$
 
 
 	JavaPersistentAttribute getJavaPersistentAttribute();
-	String JAVA_PERSISTENT_ATTRIBUTE_PROPERTY = "javaPersistentAttributeProperty";
+	String JAVA_PERSISTENT_ATTRIBUTE_PROPERTY = "javaPersistentAttribute"; //$NON-NLS-1$
 	
 	/**
 	 * Attributes are a sequence in the orm schema. We must keep
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/OrmJpaContextNode.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/OrmJpaContextNode.java
index acf75e0219..3b9285af17 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/OrmJpaContextNode.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/OrmJpaContextNode.java
@@ -31,7 +31,7 @@ public interface OrmJpaContextNode
 	/**
 	 * Add to the list of current validation messages.
 	 */
-	void addToMessages(List<IMessage> messages);
+	void validate(List<IMessage> messages);
 
 	TextRange getValidationTextRange();
 
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/MappingFileRef.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/MappingFileRef.java
index b48a27d9ec..888ff3de9d 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/MappingFileRef.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/MappingFileRef.java
@@ -38,7 +38,7 @@ public interface MappingFileRef extends PersistenceJpaContextNode, JpaStructureN
 	/**
 	 * String constant associated with changes to the file name
 	 */
-	String FILE_NAME_PROPERTY = "fileNameProperty";
+	String FILE_NAME_PROPERTY = "fileName"; //$NON-NLS-1$
 	
 	/**
 	 * Return the file name of the mapping file ref.
@@ -53,7 +53,7 @@ public interface MappingFileRef extends PersistenceJpaContextNode, JpaStructureN
 	
 	// **************** orm xml ************************************************
 	
-	String ORM_XML_PROPERTY = "ormXmlProperty";
+	String ORM_XML_PROPERTY = "ormXml"; //$NON-NLS-1$
 	
 	OrmXml getOrmXml();	
 	
@@ -73,9 +73,9 @@ public interface MappingFileRef extends PersistenceJpaContextNode, JpaStructureN
 	
 	/**
 	 * Return the OrmPersistentType listed in this mapping file
-	 * with the given fullyQualifiedTypeName.  Return null if none exists.
+	 * with the given name.  Return null if none exists.
 	 */
-	OrmPersistentType getPersistentType(String fullyQualifiedTypeName);
+	OrmPersistentType getPersistentType(String typeName);
 	
 	/**
 	 * Return whether the text representation of this persistence unit contains
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/PersistenceJpaContextNode.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/PersistenceJpaContextNode.java
index 46468ce8b6..6831dc6d01 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/PersistenceJpaContextNode.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/PersistenceJpaContextNode.java
@@ -30,7 +30,7 @@ public interface PersistenceJpaContextNode extends JpaContextNode
 	/**
 	 * Add to the list of current validation messages
 	 */
-	void addToMessages(List<IMessage> messages);
+	void validate(List<IMessage> messages);
 
 	TextRange getValidationTextRange();
 
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/PersistenceUnit.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/PersistenceUnit.java
index 39e22015f4..776ed1e511 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/PersistenceUnit.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/persistence/PersistenceUnit.java
@@ -9,13 +9,24 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.context.persistence;
 
+import java.util.Iterator;
+import java.util.List;
 import java.util.ListIterator;
+
+import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.JpaStructureNode;
 import org.eclipse.jpt.core.context.AccessType;
 import org.eclipse.jpt.core.context.Generator;
 import org.eclipse.jpt.core.context.PersistentType;
 import org.eclipse.jpt.core.context.Query;
+import org.eclipse.jpt.core.context.java.JavaGeneratedValue;
+import org.eclipse.jpt.core.context.java.JavaGenerator;
+import org.eclipse.jpt.core.context.java.JavaQuery;
+import org.eclipse.jpt.core.context.orm.OrmGeneratedValue;
+import org.eclipse.jpt.core.context.orm.OrmGenerator;
+import org.eclipse.jpt.core.context.orm.OrmQuery;
 import org.eclipse.jpt.core.resource.persistence.XmlPersistenceUnit;
+import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
 /**
  * 
@@ -401,7 +412,7 @@ public interface PersistenceUnit extends PersistenceJpaContextNode, JpaStructure
 		String DEFAULT_CASCADE_PERSIST_PROPERTY = "defaultCascadePersist"; //$NON-NLS-1$
 	
 	
-	// **************** global generator and query support *********************
+	// **************** generators *********************
 	
 	/**
 	 * Identifier for changes to the list of global generators.
@@ -424,6 +435,37 @@ public interface PersistenceUnit extends PersistenceJpaContextNode, JpaStructure
 	 * included duplicately named generators.
 	 */
 	ListIterator<Generator> allGenerators();
+
+	/**
+	 * Return an array of the names of the generators defined in the persistence
+	 * unit, with duplicates removed.
+	 */
+	String[] uniqueGeneratorNames();
+
+	/**
+	 * Validate the ORM generators held by the specified generator holder.
+	 */
+	void validateGenerators(OrmGeneratorHolder generatorHolder, List<IMessage> messages);
+
+	/**
+	 * Validate the Java generators held by the specified generator holder.
+	 */
+	void validateGenerators(JavaGeneratorHolder generatorHolder, List<IMessage> messages, CompilationUnit astRoot);
+
+	/**
+	 * Validate whether the specified ORM generated value matches a
+	 * generator defined in the persistence unit.
+	 */
+	void validateGeneratedValue(OrmGeneratedValueHolder generatedValueHolder, List<IMessage> messages);
+
+	/**
+	 * Validate whether the specified Java generated value matches a
+	 * generator defined in the persistence unit.
+	 */
+	void validateGeneratedValue(JavaGeneratedValueHolder generatedValueHolder, List<IMessage> messages, CompilationUnit astRoot);
+	
+	
+	// **************** queries *********************
 	
 	/**
 	 * Identifier for changes to the list of global queries.
@@ -447,6 +489,16 @@ public interface PersistenceUnit extends PersistenceJpaContextNode, JpaStructure
 	 */
 	ListIterator<Query> allQueries();
 	
+	/**
+	 * Validate the ORM queries held by the specified query holder.
+	 */
+	void validateQueries(OrmQueryHolder queryHolder, List<IMessage> messages);
+
+	/**
+	 * Validate the Java queries held by the specified query holder.
+	 */
+	void validateQueries(JavaQueryHolder queryHolder, List<IMessage> messages, CompilationUnit astRoot);
+
 	
 	// **************** updating ***********************************************
 	
@@ -471,4 +523,31 @@ public interface PersistenceUnit extends PersistenceJpaContextNode, JpaStructure
 	 */
 	boolean containsOffset(int textOffset);
 
+	
+	// ********** validation callbacks **********
+	
+	interface OrmGeneratorHolder {
+		Iterator<OrmGenerator> generators();
+	}
+
+	interface JavaGeneratorHolder {
+		Iterator<JavaGenerator> generators();
+	}
+
+	interface OrmGeneratedValueHolder {
+		OrmGeneratedValue getGeneratedValue();
+	}
+
+	interface JavaGeneratedValueHolder {
+		JavaGeneratedValue getGeneratedValue();
+	}
+
+	interface OrmQueryHolder {
+		Iterator<OrmQuery> queries();
+	}
+
+	interface JavaQueryHolder {
+		Iterator<JavaQuery> queries();
+	}
+
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/GenericJpaProject.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/GenericJpaProject.java
index 55cd31d4b8..60bf04e616 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/GenericJpaProject.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/GenericJpaProject.java
@@ -459,7 +459,7 @@ public class GenericJpaProject extends AbstractJpaNode implements JpaProject {
 
 	// ********** context model **********
 
-	public JpaRootContextNode getRootContext() {
+	public JpaRootContextNode getRootContextNode() {
 		return this.rootContextNode;
 	}
 
@@ -536,68 +536,51 @@ public class GenericJpaProject extends AbstractJpaNode implements JpaProject {
 	
 	public Iterator<IMessage> validationMessages() {
 		List<IMessage> messages = new ArrayList<IMessage>();
-		this.jpaPlatform.addToMessages(this, messages);
+		this.validate(messages);
 		return messages.iterator();
 	}
 	
-	public void addToMessages(List<IMessage> messages) {
-		//start with the project - then down
-		//project validation
-		addProjectLevelMessages(messages);
-		
-		//context model validation
-		getRootContext().addToMessages(messages);
-	}
-
-	protected void addProjectLevelMessages(List<IMessage> messages) {
-		this.checkConnection(messages);
-		this.checkForMultiplePersistenceXml(messages);
+	protected void validate(List<IMessage> messages) {
+		this.validateConnection(messages);
+		this.rootContextNode.validate(messages);
 	}
 
-	protected void checkConnection(List<IMessage> messages) {
+	protected void validateConnection(List<IMessage> messages) {
 		String cpName = this.dataSource.getConnectionProfileName();
-		ConnectionProfile cp = this.dataSource.getConnectionProfile();
 		if (StringTools.stringIsEmpty(cpName)) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.NORMAL_SEVERITY,
-						JpaValidationMessages.PROJECT_NO_CONNECTION,
-						this
-					)
-				);
-		} else if (cp == null) {
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.NORMAL_SEVERITY,
+					JpaValidationMessages.PROJECT_NO_CONNECTION,
+					this
+				)
+			);
+			return;
+		}
+		ConnectionProfile cp = this.dataSource.getConnectionProfile();
+		if (cp == null) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.NORMAL_SEVERITY,
-						JpaValidationMessages.PROJECT_INVALID_CONNECTION,
-						new String[] {cpName},
-						this
-					)
-				);
-		} else if (cp.isInactive()) {
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.NORMAL_SEVERITY,
+					JpaValidationMessages.PROJECT_INVALID_CONNECTION,
+					new String[] {cpName},
+					this
+				)
+			);
+			return;
+		}
+		if (cp.isInactive()) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.NORMAL_SEVERITY,
-						JpaValidationMessages.PROJECT_INACTIVE_CONNECTION,
-						new String[] {cpName},
-						this
-					)
-				);
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.NORMAL_SEVERITY,
+					JpaValidationMessages.PROJECT_INACTIVE_CONNECTION,
+					new String[] {cpName},
+					this
+				)
+			);
 		}
 	}
 	
-	protected void checkForMultiplePersistenceXml(@SuppressWarnings("unused") List<IMessage> messages) {
-//		if (validPersistenceXmlFiles.size() > 1) {
-//			messages.add(
-//					JpaValidationMessages.buildMessage(
-//						IMessage.HIGH_SEVERITY,
-//						IJpaValidationMessages.PROJECT_MULTIPLE_PERSISTENCE_XML,
-//						jpaProject
-//					)
-//				);
-//		}
-	}
-	
 	
 	// ********** root deploy location **********
 
@@ -767,7 +750,7 @@ public class GenericJpaProject extends AbstractJpaNode implements JpaProject {
 	 */
 	public IStatus update(IProgressMonitor monitor) {
 		try {
-			this.getRootContext().update(monitor);
+			this.rootContextNode.update(monitor);
 		} catch (OperationCanceledException ex) {
 			return Status.CANCEL_STATUS;
 		} catch (Throwable ex) {
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/GenericRootContextNode.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/GenericRootContextNode.java
index fc1164d533..0052460bce 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/GenericRootContextNode.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/GenericRootContextNode.java
@@ -11,6 +11,8 @@ package org.eclipse.jpt.core.internal.context;
 
 import java.util.Collection;
 import java.util.List;
+
+import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IProgressMonitor;
@@ -20,8 +22,10 @@ import org.eclipse.jpt.core.context.JpaContextNode;
 import org.eclipse.jpt.core.context.JpaRootContextNode;
 import org.eclipse.jpt.core.context.orm.EntityMappings;
 import org.eclipse.jpt.core.context.orm.OrmPersistentType;
+import org.eclipse.jpt.core.context.orm.OrmXml;
 import org.eclipse.jpt.core.context.persistence.ClassRef;
 import org.eclipse.jpt.core.context.persistence.MappingFileRef;
+import org.eclipse.jpt.core.context.persistence.Persistence;
 import org.eclipse.jpt.core.context.persistence.PersistenceUnit;
 import org.eclipse.jpt.core.context.persistence.PersistenceXml;
 import org.eclipse.jpt.core.internal.resource.persistence.PersistenceResourceModelProvider;
@@ -31,10 +35,15 @@ import org.eclipse.jpt.core.internal.validation.JpaValidationMessages;
 import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType;
 import org.eclipse.jpt.core.resource.persistence.PersistenceResource;
 import org.eclipse.jpt.utility.internal.CollectionTools;
+import org.eclipse.jpt.utility.internal.HashBag;
 import org.eclipse.wst.common.internal.emfworkbench.WorkbenchResourceHelper;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
-public class GenericRootContextNode extends AbstractJpaContextNode 
+/**
+ * 
+ */
+public class GenericRootContextNode
+	extends AbstractJpaContextNode 
 	implements JpaRootContextNode
 {
 	/* This object has no parent, so it must point to the JPA project */
@@ -47,7 +56,7 @@ public class GenericRootContextNode extends AbstractJpaContextNode
 	public GenericRootContextNode(JpaProject jpaProject) {
 		super(null);
 		if (jpaProject == null) {
-			throw new IllegalArgumentException("The JPA project must not be null");
+			throw new IllegalArgumentException("The JPA project must not be null"); //$NON-NLS-1$
 		}
 		this.jpaProject = jpaProject;
 		
@@ -74,7 +83,11 @@ public class GenericRootContextNode extends AbstractJpaContextNode
 	
 	@Override
 	public IResource getResource() {
-		return getJpaProject().getProject();
+		return this.getProject();
+	}
+	
+	protected IProject getProject() {
+		return this.jpaProject.getProject();
 	}
 	
 	@Override
@@ -121,7 +134,7 @@ public class GenericRootContextNode extends AbstractJpaContextNode
 			throw new IllegalStateException();
 		}
 		PersistenceResourceModelProvider modelProvider =
-			PersistenceResourceModelProvider.getDefaultModelProvider(getJpaProject().getProject());
+			PersistenceResourceModelProvider.getDefaultModelProvider(this.getProject());
 		PersistenceResource resource = modelProvider.getResource();
 		modelProvider.modify(new Runnable() {
 				public void run() {
@@ -181,83 +194,66 @@ public class GenericRootContextNode extends AbstractJpaContextNode
 	
 	// **************** Validation *********************************************
 	
-	/* If this is true, it may be assumed that all the requirements are valid 
-	 * for further validation.  For example, if this is true at the point we
-	 * are validating persistence units, it may be assumed that there is a 
-	 * single persistence.xml and that it has valid content down to the 
-	 * persistence unit level.  */
-	private boolean okToContinueValidation = true;
-	
-	public void addToMessages(List<IMessage> messages) {
-		addNoPersistenceXmlMessage(messages);
-		//TODO - multiple persistence unit message
-		addOrphanedJavaClassMessages(messages);
-		
-		if(okToContinueValidation) {
-			getPersistenceXml().addToMessages(messages);
-		}
-		
-	}
-	
-	protected void addNoPersistenceXmlMessage(List<IMessage> messages) {
-		if (persistenceXml == null) {
+	public void validate(List<IMessage> messages) {
+		if (this.persistenceXml == null) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY, 
-						JpaValidationMessages.PROJECT_NO_PERSISTENCE_XML,
-						this)
-				);
-			okToContinueValidation = false;
-		}
-	}
-	
-	
-
-	
-	protected void addOrphanedJavaClassMessages(List<IMessage> messages) {
-		if (getPersistenceXml() == null) {
-			//handled with other validation
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY, 
+					JpaValidationMessages.PROJECT_NO_PERSISTENCE_XML,
+					this
+				)
+			);
 			return;
 		}
-		if (getPersistenceXml().getPersistence() == null) {
-			//handled with other validation
-			return;
+		if ( ! this.jpaProject.discoversAnnotatedClasses()) {
+			this.validateOrphanClasses(messages);
 		}
-		if (getJpaProject().discoversAnnotatedClasses()) {
+		this.persistenceXml.validate(messages);
+	}
+
+	protected void validateOrphanClasses(List<IMessage> messages) {
+		Persistence persistence = this.persistenceXml.getPersistence();
+		if (persistence == null) {
+			// handled with other validation
 			return;
 		}
-		Collection<String> orphanedClassNames = CollectionTools.collection(getJpaProject().annotatedClassNames());
-		if (getPersistenceXml().getPersistence().persistenceUnitsSize() != 1) {
-			//context model currently only supports 1 persistenceUnit
+		if (persistence.persistenceUnitsSize() != 1) {
+			// the context model currently only supports 1 persistence unit
 			return;
 		}
-		PersistenceUnit persistenceUnit = getPersistenceXml().getPersistence().persistenceUnits().next();
-		for (String typeName : CollectionTools.iterable(getJpaProject().annotatedClassNames())) {
+		PersistenceUnit persistenceUnit = persistence.persistenceUnits().next();
+		HashBag<String> orphans = CollectionTools.bag(this.jpaProject.annotatedClassNames());
+		for (String typeName : CollectionTools.iterable(this.jpaProject.annotatedClassNames())) {
 			for (ClassRef classRef : CollectionTools.iterable(persistenceUnit.specifiedClassRefs())) {
 				if (classRef.isFor(typeName)) {
-					orphanedClassNames.remove(typeName);
+					orphans.remove(typeName);
 				}
 			}
 			for (MappingFileRef mappingFileRef : CollectionTools.iterable(persistenceUnit.mappingFileRefs())) {
-				if (mappingFileRef.getOrmXml() == null || mappingFileRef.getOrmXml().getEntityMappings() == null) {
-					continue;
-				}
-				if (mappingFileRef.getOrmXml().getEntityMappings().getPersistentType(typeName) != null) {
-					orphanedClassNames.remove(typeName);
+				OrmXml ormXml = mappingFileRef.getOrmXml();
+				if (ormXml != null) {
+					EntityMappings entityMappings = ormXml.getEntityMappings();
+					if (entityMappings != null) {
+						if (entityMappings.getPersistentType(typeName) != null) {
+							orphans.remove(typeName);
+						}
+					}
 				}
 			}
 		}
 		
-		for (String orphanedTypeName : orphanedClassNames) {
-			JavaResourcePersistentType javaResourcePersistentType = getJpaProject().getJavaResourcePersistentType(orphanedTypeName);
+		for (String orphan : orphans) {
+			JavaResourcePersistentType javaResourcePersistentType = this.jpaProject.getJavaResourcePersistentType(orphan);
 				messages.add(
-						DefaultJpaValidationMessages.buildMessage(
-							IMessage.HIGH_SEVERITY,
-							JpaValidationMessages.PERSISTENT_TYPE_UNSPECIFIED_CONTEXT,
-							new String[] {persistenceUnit.getName()},
-							javaResourcePersistentType.getResourceModel().getFile(),
-							javaResourcePersistentType.getMappingAnnotation().getTextRange(JDTTools.buildASTRoot(javaResourcePersistentType.getJpaCompilationUnit().getCompilationUnit())))
-					);
+					DefaultJpaValidationMessages.buildMessage(
+						IMessage.HIGH_SEVERITY,
+						JpaValidationMessages.PERSISTENT_TYPE_UNSPECIFIED_CONTEXT,
+						new String[] {persistenceUnit.getName()},
+						javaResourcePersistentType.getResourceModel().getFile(),
+						javaResourcePersistentType.getMappingAnnotation().getTextRange(JDTTools.buildASTRoot(javaResourcePersistentType.getJpaCompilationUnit().getCompilationUnit()))
+					)
+				);
 		}
 	}
+
 }
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 d6347ef055..e65cc55f1f 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
@@ -66,7 +66,7 @@ public abstract class AbstractJavaAttributeMapping<T extends JavaResourceNode>
 		return this.getTypeMapping().getKey() == MappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY;
 	}
 	
-	protected boolean entityOwned() {
+	protected boolean ownerIsEntity() {
 		return this.getTypeMapping().getKey() == MappingKeys.ENTITY_TYPE_MAPPING_KEY;
 	}
 	
@@ -120,47 +120,40 @@ public abstract class AbstractJavaAttributeMapping<T extends JavaResourceNode>
 	//************ Validation *************************
 	
 	@Override
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		super.addToMessages(messages, astRoot);
-		
-		this.checkModifiers(messages, astRoot);
-		this.checkMappingType(messages, astRoot);
+	public void validate(List<IMessage> messages, CompilationUnit astRoot) {
+		super.validate(messages, astRoot);
+		this.validateModifiers(messages, astRoot);
+		this.validateMappingType(messages, astRoot);
 	}
 	
-	protected void checkModifiers(List<IMessage> messages, CompilationUnit astRoot) {
-		JavaPersistentAttribute attribute = this.getPersistentAttribute();
-		if (attribute.getMappingKey() == MappingKeys.TRANSIENT_ATTRIBUTE_MAPPING_KEY) {
+	protected void validateModifiers(List<IMessage> messages, CompilationUnit astRoot) {
+		if (this.getPersistentAttribute().getMappingKey() == MappingKeys.TRANSIENT_ATTRIBUTE_MAPPING_KEY) {
 			return;
 		}
 		
 		if (this.resourcePersistentAttribute.isForField()) {
 			if (this.resourcePersistentAttribute.isFinal()) {
-				messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.PERSISTENT_ATTRIBUTE_FINAL_FIELD,
-						new String[] {attribute.getName()},
-						attribute,
-						attribute.getValidationTextRange(astRoot)
-					)
-				);
+				messages.add(this.buildAttributeMessage(JpaValidationMessages.PERSISTENT_ATTRIBUTE_FINAL_FIELD, astRoot));
 			}
 			
 			if (this.resourcePersistentAttribute.isPublic()) {
-				messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.PERSISTENT_ATTRIBUTE_PUBLIC_FIELD,
-						new String[] {attribute.getName()},
-						attribute,
-						attribute.getValidationTextRange(astRoot)
-					)
-				);
+				messages.add(this.buildAttributeMessage(JpaValidationMessages.PERSISTENT_ATTRIBUTE_PUBLIC_FIELD, astRoot));
 			}
 		}
 	}
+
+	protected IMessage buildAttributeMessage(String msgID, CompilationUnit astRoot) {
+		JavaPersistentAttribute attribute = this.getPersistentAttribute();
+		return DefaultJpaValidationMessages.buildMessage(
+				IMessage.HIGH_SEVERITY,
+				msgID,
+				new String[] {attribute.getName()},
+				attribute,
+				attribute.getValidationTextRange(astRoot)
+			);
+	}
 	
-	protected void checkMappingType(List<IMessage> messages, CompilationUnit astRoot) {
+	protected void validateMappingType(List<IMessage> messages, CompilationUnit astRoot) {
 		if ( ! this.getTypeMapping().attributeMappingKeyAllowed(this.getKey())) {
 			messages.add(
 				DefaultJpaValidationMessages.buildMessage(
@@ -184,4 +177,9 @@ public abstract class AbstractJavaAttributeMapping<T extends JavaResourceNode>
 		return (resourceMapping == null) ? null : resourceMapping.getTextRange(astRoot);
 	}
 	
+	@Override
+	public void toString(StringBuilder sb) {
+		sb.append(this.getAttributeName());
+	}
+
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaBaseEmbeddedMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaBaseEmbeddedMapping.java
index 0884fb7ffd..fbf6fdbd07 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaBaseEmbeddedMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaBaseEmbeddedMapping.java
@@ -356,11 +356,11 @@ public abstract class AbstractJavaBaseEmbeddedMapping<T extends JavaResourceNode
 	//******** Validation ******************
 	
 	@Override
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		super.addToMessages(messages, astRoot);
+	public void validate(List<IMessage> messages, CompilationUnit astRoot) {
+		super.validate(messages, astRoot);
 		
 		for (Iterator<JavaAttributeOverride> stream = attributeOverrides(); stream.hasNext();) {
-			stream.next().addToMessages(messages, astRoot);
+			stream.next().validate(messages, astRoot);
 		}
 	}
 }
\ No newline at end of file
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaJpaContextNode.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaJpaContextNode.java
index 96f693146a..635b85ac9b 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaJpaContextNode.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaJpaContextNode.java
@@ -56,7 +56,7 @@ public abstract class AbstractJavaJpaContextNode
 	 * All subclass implementations {@link #addToMessages(List, CompilationUnit))} 
 	 * should be preceded by a "super" call to this method
 	 */
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
+	public void validate(List<IMessage> messages, CompilationUnit astRoot) {
 		// do nothing by default
 	}
 
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 282fc15b83..558ed73d5c 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
@@ -171,7 +171,7 @@ public abstract class AbstractJavaMultiRelationshipMapping<T extends Relationshi
 		boolean oldCustomOrdering = this.isCustomOrdering;
 		this.isCustomOrdering = newCustomOrdering;
 		if (newCustomOrdering) {
-			setOrderBy("");
+			setOrderBy(""); //$NON-NLS-1$
 		}
 		firePropertyChanged(CUSTOM_ORDERING_PROPERTY, oldCustomOrdering, newCustomOrdering);
 	}
@@ -190,8 +190,8 @@ public abstract class AbstractJavaMultiRelationshipMapping<T extends Relationshi
 		return this.joinTable;
 	}
 
-	public boolean isJoinTableSpecified() {
-		return getJoinTable().isSpecified();
+	public boolean joinTableIsSpecified() {
+		return this.joinTable.isSpecified();
 	}
 
 	public boolean isRelationshipOwner() {
@@ -245,11 +245,11 @@ public abstract class AbstractJavaMultiRelationshipMapping<T extends Relationshi
 //	}
 
 	@Override
-	protected String buildDefaultTargetEntity(JavaResourcePersistentAttribute resourcePersistentAttribute) {
-		if (!resourcePersistentAttribute.typeIsContainer()) {
+	protected String buildDefaultTargetEntity(JavaResourcePersistentAttribute jrpa) {
+		if (!jrpa.typeIsContainer()) {
 			return null;
 		}
-		return resourcePersistentAttribute.getQualifiedReferenceEntityElementTypeName();
+		return jrpa.getQualifiedReferenceEntityElementTypeName();
 	}
 	
 	protected abstract boolean mappedByTouches(int pos, CompilationUnit astRoot);
@@ -261,8 +261,8 @@ public abstract class AbstractJavaMultiRelationshipMapping<T extends Relationshi
 		return false;
 	}
 	
-	protected MapKeyAnnotation getMapKeyResource(JavaResourcePersistentAttribute resourcePersistentAttribute) {
-		return (MapKeyAnnotation) resourcePersistentAttribute.getAnnotation(MapKeyAnnotation.ANNOTATION_NAME);
+	protected MapKeyAnnotation getMapKeyResource(JavaResourcePersistentAttribute jrpa) {
+		return (MapKeyAnnotation) jrpa.getAnnotation(MapKeyAnnotation.ANNOTATION_NAME);
 	}
 
 	public Iterator<String> candidateMapKeyNames() {
@@ -283,7 +283,7 @@ public abstract class AbstractJavaMultiRelationshipMapping<T extends Relationshi
 		if (result != null) {
 			return result;
 		}
-		result = this.getJoinTable().javaCompletionProposals(pos, filter, astRoot);
+		result = this.joinTable.javaCompletionProposals(pos, filter, astRoot);
 		if (result != null) {
 			return result;
 		}
@@ -297,14 +297,14 @@ public abstract class AbstractJavaMultiRelationshipMapping<T extends Relationshi
 	}
 	
 	@Override
-	public void initialize(JavaResourcePersistentAttribute resourcePersistentAttribute) {
-		super.initialize(resourcePersistentAttribute);
-		MapKeyAnnotation mapKey = this.getMapKeyResource(resourcePersistentAttribute);
-		if (mapKey != null) {
-			this.mapKey = mapKey.getName();
+	public void initialize(JavaResourcePersistentAttribute jrpa) {
+		super.initialize(jrpa);
+		MapKeyAnnotation mapKeyAnnotation = this.getMapKeyResource(jrpa);
+		if (mapKeyAnnotation != null) {
+			this.mapKey = mapKeyAnnotation.getName();
 		}
 		this.initializeOrderBy(this.getResourceOrderBy());
-		this.joinTable.initialize(resourcePersistentAttribute);
+		this.joinTable.initialize(jrpa);
 	}
 	
 	@Override
@@ -313,10 +313,10 @@ public abstract class AbstractJavaMultiRelationshipMapping<T extends Relationshi
 		this.mappedBy = this.mappedBy(relationshipMapping);
 	}
 	
-	protected void initializeOrderBy(OrderByAnnotation orderBy) {
-		if (orderBy != null) {
-			this.orderBy = orderBy.getValue();
-			if (orderBy.getValue() == null) {
+	protected void initializeOrderBy(OrderByAnnotation orderByAnnotation) {
+		if (orderByAnnotation != null) {
+			this.orderBy = orderByAnnotation.getValue();
+			if (orderByAnnotation.getValue() == null) {
 				this.isPkOrdering = true;
 			}
 			else {
@@ -329,11 +329,11 @@ public abstract class AbstractJavaMultiRelationshipMapping<T extends Relationshi
 	}
 	
 	@Override
-	public void update(JavaResourcePersistentAttribute resourcePersistentAttribute) {
-		super.update(resourcePersistentAttribute);
-		this.updateMapKey(resourcePersistentAttribute);
+	public void update(JavaResourcePersistentAttribute jrpa) {
+		super.update(jrpa);
+		this.updateMapKey(jrpa);
 		this.updateOrderBy(this.getResourceOrderBy());
-		this.joinTable.update(resourcePersistentAttribute);
+		this.joinTable.update(jrpa);
 	}	
 	
 	@Override
@@ -342,20 +342,20 @@ public abstract class AbstractJavaMultiRelationshipMapping<T extends Relationshi
 		this.setMappedBy_(this.mappedBy(relationshipMapping));
 	}
 	
-	protected void updateMapKey(JavaResourcePersistentAttribute resourcePersistentAttribute) {
-		MapKeyAnnotation mapKey = this.getMapKeyResource(resourcePersistentAttribute);
-		if (mapKey != null) {
-			setMapKey_(mapKey.getName());
+	protected void updateMapKey(JavaResourcePersistentAttribute jrpa) {
+		MapKeyAnnotation mapKeyAnnotation = this.getMapKeyResource(jrpa);
+		if (mapKeyAnnotation != null) {
+			setMapKey_(mapKeyAnnotation.getName());
 		}
 		else {
 			setMapKey_(null);
 		}
 	}
 	
-	protected void updateOrderBy(OrderByAnnotation orderBy) {
-		if (orderBy != null) {
-			setOrderBy_(orderBy.getValue());
-			if (orderBy.getValue() == null) {
+	protected void updateOrderBy(OrderByAnnotation orderByAnnotation) {
+		if (orderByAnnotation != null) {
+			setOrderBy_(orderByAnnotation.getValue());
+			if (orderByAnnotation.getValue() == null) {
 				setPkOrdering_(true);
 				setCustomOrdering_(false);
 				setNoOrdering_(false);
@@ -373,34 +373,36 @@ public abstract class AbstractJavaMultiRelationshipMapping<T extends Relationshi
 			setNoOrdering_(true);
 		}
 	}
+
 	protected abstract String mappedBy(T relationshipMapping);
 
-	//******** Validation ***********************************
+
+	// ********** validation **********
 	
 	public abstract TextRange getMappedByTextRange(CompilationUnit astRoot);
 	
 	@Override
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		super.addToMessages(messages, astRoot);
+	public void validate(List<IMessage> messages, CompilationUnit astRoot) {
+		super.validate(messages, astRoot);
 		
-		if (entityOwned() && (this.isJoinTableSpecified() || isRelationshipOwner())) {
-			getJoinTable().addToMessages(messages, astRoot);
+		if (this.ownerIsEntity() && (this.joinTableIsSpecified() || this.isRelationshipOwner())) {
+			this.joinTable.validate(messages, astRoot);
 		}
 		if (this.getMappedBy() != null) {
-			addMappedByMessages(messages, astRoot);
+			this.validateMappedBy(messages, astRoot);
 		}
 	}
 	
-	protected void addMappedByMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		if (this.isJoinTableSpecified()) {
+	protected void validateMappedBy(List<IMessage> messages, CompilationUnit astRoot) {
+		if (this.joinTableIsSpecified()) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.MAPPING_MAPPED_BY_WITH_JOIN_TABLE,
-						this.getJoinTable(), 
-						this.getJoinTable().getValidationTextRange(astRoot))
-				);
-						
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.MAPPING_MAPPED_BY_WITH_JOIN_TABLE,
+					this.joinTable, 
+					this.joinTable.getValidationTextRange(astRoot)
+				)
+			);
 		}
 		
 		Entity targetEntity = this.getResolvedTargetEntity();
@@ -414,38 +416,42 @@ public abstract class AbstractJavaMultiRelationshipMapping<T extends Relationshi
 		
 		if (attribute == null) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.MAPPING_UNRESOLVED_MAPPED_BY,
-						new String[] {this.mappedBy}, 
-						this, 
-						this.getMappedByTextRange(astRoot))
-				);
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.MAPPING_UNRESOLVED_MAPPED_BY,
+					new String[] {this.mappedBy}, 
+					this, 
+					this.getMappedByTextRange(astRoot)
+				)
+			);
 			return;
 		}
-		
-		if (! this.mappedByIsValid(attribute.getMapping())) {
+
+		AttributeMapping mappedByMapping = attribute.getMapping();
+		if ( ! this.mappedByIsValid(mappedByMapping)) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.MAPPING_INVALID_MAPPED_BY,
-						new String[] {this.mappedBy}, 
-						this, 
-						this.getMappedByTextRange(astRoot))
-				);
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.MAPPING_INVALID_MAPPED_BY,
+					new String[] {this.mappedBy}, 
+					this, 
+					this.getMappedByTextRange(astRoot)
+				)
+			);
 			return;
 		}
 		
-		AttributeMapping mappedByMapping = attribute.getMapping();
 		if ((mappedByMapping instanceof NonOwningMapping)
 				&& ((NonOwningMapping) mappedByMapping).getMappedBy() != null) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.MAPPING_MAPPED_BY_ON_BOTH_SIDES,
-						this, 
-						this.getMappedByTextRange(astRoot))
-				);
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.MAPPING_MAPPED_BY_ON_BOTH_SIDES,
+					this, 
+					this.getMappedByTextRange(astRoot)
+				)
+			);
 		}
 	}
+
 }
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 f55a724f09..468beb1767 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
@@ -325,34 +325,36 @@ public abstract class AbstractJavaSingleRelationshipMapping<T extends Relationsh
 	// ********** validation **********
 
 	@Override
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		super.addToMessages(messages, astRoot);
+	public void validate(List<IMessage> messages, CompilationUnit astRoot) {
+		super.validate(messages, astRoot);
 		
 		if (this.connectionProfileIsActive()) {
-			this.checkJoinColumns(messages, astRoot);
+			this.validateJoinColumns(messages, astRoot);
 		}
 	}
 	
-	//bug 192287 - do not want joinColumn validation errors on the non-owning side
-	//of a bidirectional relationship.  This is a low risk fix for RC3, but a better
-	//solution would be to not have the default joinColumns on the non-owning side.
-	//This would fix another bug that we show default joinColumns in this situation.
-	protected void checkJoinColumns(List<IMessage> messages, CompilationUnit astRoot) {
-		if (this.entityOwned() && this.isRelationshipOwner()) {
+	// 192287 - We don't want join column validation errors on the non-owning side
+	// of a bidirectional relationship. This is a low risk fix for RC3, but a better
+	// solution would be to not have the default join columns on the non-owning side.
+	// This would fix another bug that we show default join columns in this situation.
+	protected void validateJoinColumns(List<IMessage> messages, CompilationUnit astRoot) {
+		if (this.ownerIsEntity() && this.isRelationshipOwner()) {
 			for (Iterator<JavaJoinColumn> stream = this.joinColumns(); stream.hasNext(); ) {
-				this.checkJoinColumn(stream.next(), messages, astRoot);
+				this.validateJoinColumn(stream.next(), messages, astRoot);
 			}
 		}
 	}
 
-	protected void checkJoinColumn(JavaJoinColumn joinColumn, List<IMessage> messages, CompilationUnit astRoot) {
+	protected void validateJoinColumn(JavaJoinColumn joinColumn, List<IMessage> messages, CompilationUnit astRoot) {
 		if (this.getTypeMapping().tableNameIsInvalid(joinColumn.getTable())) {
 			messages.add(
 				DefaultJpaValidationMessages.buildMessage(
 					IMessage.HIGH_SEVERITY,
 					JpaValidationMessages.JOIN_COLUMN_UNRESOLVED_TABLE,
 					new String[] {joinColumn.getTable(), joinColumn.getName()}, 
-					joinColumn, joinColumn.getTableTextRange(astRoot))
+					joinColumn,
+					joinColumn.getTableTextRange(astRoot)
+				)
 			);
 			return;
 		}
@@ -363,7 +365,9 @@ public abstract class AbstractJavaSingleRelationshipMapping<T extends Relationsh
 					IMessage.HIGH_SEVERITY,
 					JpaValidationMessages.JOIN_COLUMN_UNRESOLVED_NAME,
 					new String[] {joinColumn.getName()}, 
-					joinColumn, joinColumn.getNameTextRange(astRoot))
+					joinColumn,
+					joinColumn.getNameTextRange(astRoot)
+				)
 			);
 		}
 
@@ -373,13 +377,15 @@ public abstract class AbstractJavaSingleRelationshipMapping<T extends Relationsh
 					IMessage.HIGH_SEVERITY,
 					JpaValidationMessages.JOIN_COLUMN_REFERENCED_COLUMN_UNRESOLVED_NAME,
 					new String[] {joinColumn.getReferencedColumnName(), joinColumn.getName()}, 
-					joinColumn, joinColumn.getReferencedColumnNameTextRange(astRoot))
+					joinColumn,
+					joinColumn.getReferencedColumnNameTextRange(astRoot)
+				)
 			);
 		}
 	}
 
 
-	// ********** JavaJoinColumn.Owner implementation **********
+	// ********** join column owner adapter **********
 
 	public class JoinColumnOwner implements JavaJoinColumn.Owner {
 
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaTypeMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaTypeMapping.java
index 04208f1345..fe05318c27 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaTypeMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaTypeMapping.java
@@ -126,4 +126,10 @@ public abstract class AbstractJavaTypeMapping extends AbstractJavaJpaContextNode
 		TextRange textRange = this.getResourceMapping().getTextRange(astRoot);
 		return (textRange != null) ? textRange : this.getPersistentType().getValidationTextRange(astRoot);
 	}
+
+	@Override
+	public void toString(StringBuilder sb) {
+		sb.append(this.getPersistentType().getName());
+	}
+
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaAssociationOverride.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaAssociationOverride.java
index a28c2b7024..8560cb5549 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaAssociationOverride.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaAssociationOverride.java
@@ -197,38 +197,38 @@ public class GenericJavaAssociationOverride extends AbstractJavaOverride
 	// ********** validation **********
 
 	@Override
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		super.addToMessages(messages, astRoot);
+	public void validate(List<IMessage> messages, CompilationUnit astRoot) {
+		super.validate(messages, astRoot);
 		if (this.connectionProfileIsActive()) {
-			this.checkDatabase(messages, astRoot);
+			this.validateJoinColumns(messages, astRoot);
 		}
 	}
 	
-	protected void checkDatabase(List<IMessage> messages, CompilationUnit astRoot) {
+	protected void validateJoinColumns(List<IMessage> messages, CompilationUnit astRoot) {
 		for (Iterator<JavaJoinColumn> stream = this.joinColumns(); stream.hasNext(); ) {
-			this.checkDatabase(stream.next(), messages, astRoot);
+			this.validateJoinColumn(stream.next(), messages, astRoot);
 		}
 	}
 
-	protected void checkDatabase(JavaJoinColumn joinColumn, List<IMessage> messages, CompilationUnit astRoot) {
-		if (this.getOwner().getTypeMapping().tableNameIsInvalid(joinColumn.getTable())) {
+	protected void validateJoinColumn(JavaJoinColumn joinColumn, List<IMessage> messages, CompilationUnit astRoot) {
+		String tableName = joinColumn.getTable();
+		if (this.getOwner().getTypeMapping().tableNameIsInvalid(tableName)) {
 			if (this.isVirtual()) {
 				messages.add(
 					DefaultJpaValidationMessages.buildMessage(
 						IMessage.HIGH_SEVERITY,
 						JpaValidationMessages.VIRTUAL_ASSOCIATION_OVERRIDE_JOIN_COLUMN_UNRESOLVED_TABLE,
-						new String[] {this.getName(), joinColumn.getTable(), joinColumn.getName()},
+						new String[] {this.getName(), tableName, joinColumn.getName()},
 						joinColumn, 
 						joinColumn.getTableTextRange(astRoot)
 					)
 				);
-			}
-			else {
+			} else {
 				messages.add(
 					DefaultJpaValidationMessages.buildMessage(
 						IMessage.HIGH_SEVERITY,
 						JpaValidationMessages.JOIN_COLUMN_UNRESOLVED_TABLE,
-						new String[] {joinColumn.getTable(), joinColumn.getName()}, 
+						new String[] {tableName, joinColumn.getName()}, 
 						joinColumn,
 						joinColumn.getTableTextRange(astRoot)
 					)
@@ -248,8 +248,7 @@ public class GenericJavaAssociationOverride extends AbstractJavaOverride
 						joinColumn.getNameTextRange(astRoot)
 					)
 				);
-			}
-			else {
+			} else {
 				messages.add(
 					DefaultJpaValidationMessages.buildMessage(
 						IMessage.HIGH_SEVERITY,
@@ -273,8 +272,7 @@ public class GenericJavaAssociationOverride extends AbstractJavaOverride
 						joinColumn.getReferencedColumnNameTextRange(astRoot)
 					)
 				);
-			}
-			else {
+			} else {
 				messages.add(
 					DefaultJpaValidationMessages.buildMessage(
 						IMessage.HIGH_SEVERITY,
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaAttributeOverride.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaAttributeOverride.java
index d90c886cf0..641058777f 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaAttributeOverride.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaAttributeOverride.java
@@ -127,62 +127,66 @@ public class GenericJavaAttributeOverride extends AbstractJavaOverride
 		}
 		return null;
 	}
-	
-	
-	//******************** validation **********************
+
+
+	// ********** validation **********
+
 	@Override
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		super.addToMessages(messages, astRoot);
+	public void validate(List<IMessage> messages, CompilationUnit astRoot) {
+		super.validate(messages, astRoot);
 		if (this.connectionProfileIsActive()) {
-			this.addColumnMessages(messages, astRoot);
+			this.validateColumn(messages, astRoot);
 		}
 	}
-	
-	protected void addColumnMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		if (this.getTypeMapping().tableNameIsInvalid(this.column.getTable())) {
-			if (isVirtual()) {
+
+	protected void validateColumn(List<IMessage> messages, CompilationUnit astRoot) {
+		String tableName = this.column.getTable();
+		if (this.getTypeMapping().tableNameIsInvalid(tableName)) {
+			if (this.isVirtual()) {
 				messages.add(
 					DefaultJpaValidationMessages.buildMessage(
 						IMessage.HIGH_SEVERITY,
 						JpaValidationMessages.VIRTUAL_ATTRIBUTE_OVERRIDE_COLUMN_UNRESOLVED_TABLE,
-						new String[] {this.getName(), this.column.getTable(), this.column.getName()},
+						new String[] {this.getName(), tableName, this.column.getName()},
 						this.column,
-						this.column.getTableTextRange(astRoot))
+						this.column.getTableTextRange(astRoot)
+					)
 				);
-			}
-			else {
+			} else {
 				messages.add(
-						DefaultJpaValidationMessages.buildMessage(
-							IMessage.HIGH_SEVERITY,
-							JpaValidationMessages.COLUMN_UNRESOLVED_TABLE,
-							new String[] {this.column.getTable(), this.column.getName()}, 
-							this.column,
-							this.column.getTableTextRange(astRoot))
-					);
+					DefaultJpaValidationMessages.buildMessage(
+						IMessage.HIGH_SEVERITY,
+						JpaValidationMessages.COLUMN_UNRESOLVED_TABLE,
+						new String[] {tableName, this.column.getName()}, 
+						this.column,
+						this.column.getTableTextRange(astRoot)
+					)
+				);
 			}
 			return;
 		}
 		
 		if ( ! this.column.isResolved()) {
-			if (isVirtual()) {
+			if (this.isVirtual()) {
 				messages.add(
 					DefaultJpaValidationMessages.buildMessage(
 						IMessage.HIGH_SEVERITY,
 						JpaValidationMessages.VIRTUAL_ATTRIBUTE_OVERRIDE_COLUMN_UNRESOLVED_NAME,
 						new String[] {this.getName(), this.column.getName()},
 						this.column,
-						this.column.getNameTextRange(astRoot))
+						this.column.getNameTextRange(astRoot)
+					)
 				);
-			}
-			else {
+			} else {
 				messages.add(
-						DefaultJpaValidationMessages.buildMessage(
-							IMessage.HIGH_SEVERITY,
-							JpaValidationMessages.COLUMN_UNRESOLVED_NAME,
-							new String[] {this.column.getName()}, 
-							this.column,
-							this.column.getNameTextRange(astRoot))
-					);
+					DefaultJpaValidationMessages.buildMessage(
+						IMessage.HIGH_SEVERITY,
+						JpaValidationMessages.COLUMN_UNRESOLVED_NAME,
+						new String[] {this.column.getName()},
+						this.column,
+						this.column.getNameTextRange(astRoot)
+					)
+				);
 			}
 		}
 	}
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 86390bc943..14431f33cc 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
@@ -277,39 +277,43 @@ public class GenericJavaBasicMapping extends AbstractJavaAttributeMapping<BasicA
 		}
 		return null;
 	}
-	
-	// ************** Validation *************************************
+
+
+	// ********** validation **********
 	
 	@Override
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		super.addToMessages(messages ,astRoot);
-		if (this.entityOwned() && this.connectionProfileIsActive()) {
-			this.addColumnMessages(messages, astRoot);
+	public void validate(List<IMessage> messages, CompilationUnit astRoot) {
+		super.validate(messages ,astRoot);
+		if (this.ownerIsEntity() && this.connectionProfileIsActive()) {
+			this.validateColumn(messages, astRoot);
 		}
 	}
 	
-	protected void addColumnMessages(List<IMessage> messages, CompilationUnit astRoot) {
+	protected void validateColumn(List<IMessage> messages, CompilationUnit astRoot) {
 		if (this.getTypeMapping().tableNameIsInvalid(this.column.getTable())) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.COLUMN_UNRESOLVED_TABLE,
-						new String[] {this.column.getTable(), this.column.getName()}, 
-						this.column,
-						this.column.getTableTextRange(astRoot))
-				);
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.COLUMN_UNRESOLVED_TABLE,
+					new String[] {this.column.getTable(), this.column.getName()}, 
+					this.column,
+					this.column.getTableTextRange(astRoot)
+				)
+			);
 			return;
 		}
 		
 		if ( ! this.column.isResolved()) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.COLUMN_UNRESOLVED_NAME,
-						new String[] {this.column.getName()}, 
-						this.column,
-						this.column.getNameTextRange(astRoot))
-				);
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.COLUMN_UNRESOLVED_NAME,
+					new String[] {this.column.getName()}, 
+					this.column,
+					this.column.getNameTextRange(astRoot)
+				)
+			);
 		}
 	}
+
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaEntity.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaEntity.java
index 182f82e332..f3a71f695f 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaEntity.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaEntity.java
@@ -11,6 +11,7 @@ package org.eclipse.jpt.core.internal.context.java;
 
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;
@@ -25,7 +26,6 @@ import org.eclipse.jpt.core.context.ColumnMapping;
 import org.eclipse.jpt.core.context.DiscriminatorColumn;
 import org.eclipse.jpt.core.context.DiscriminatorType;
 import org.eclipse.jpt.core.context.Entity;
-import org.eclipse.jpt.core.context.Generator;
 import org.eclipse.jpt.core.context.IdClass;
 import org.eclipse.jpt.core.context.InheritanceType;
 import org.eclipse.jpt.core.context.NamedNativeQuery;
@@ -55,6 +55,7 @@ import org.eclipse.jpt.core.context.java.JavaSecondaryTable;
 import org.eclipse.jpt.core.context.java.JavaSequenceGenerator;
 import org.eclipse.jpt.core.context.java.JavaTable;
 import org.eclipse.jpt.core.context.java.JavaTableGenerator;
+import org.eclipse.jpt.core.context.persistence.PersistenceUnit;
 import org.eclipse.jpt.core.internal.resource.java.NullAssociationOverride;
 import org.eclipse.jpt.core.internal.resource.java.NullPrimaryKeyJoinColumn;
 import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages;
@@ -88,16 +89,16 @@ import org.eclipse.jpt.utility.internal.iterators.ArrayIterator;
 import org.eclipse.jpt.utility.internal.iterators.CloneListIterator;
 import org.eclipse.jpt.utility.internal.iterators.CompositeIterator;
 import org.eclipse.jpt.utility.internal.iterators.CompositeListIterator;
-import org.eclipse.jpt.utility.internal.iterators.EmptyIterator;
 import org.eclipse.jpt.utility.internal.iterators.EmptyListIterator;
 import org.eclipse.jpt.utility.internal.iterators.FilteringIterator;
-import org.eclipse.jpt.utility.internal.iterators.SingleElementIterator;
 import org.eclipse.jpt.utility.internal.iterators.SingleElementListIterator;
 import org.eclipse.jpt.utility.internal.iterators.TransformationIterator;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
 
-public class GenericJavaEntity extends AbstractJavaTypeMapping implements JavaEntity
+public class GenericJavaEntity
+	extends AbstractJavaTypeMapping
+	implements JavaEntity, PersistenceUnit.JavaGeneratorHolder, PersistenceUnit.JavaQueryHolder
 {
 	protected EntityAnnotation entityResource;
 	
@@ -357,7 +358,7 @@ public class GenericJavaEntity extends AbstractJavaTypeMapping implements JavaEn
 					);
 	}
 
-	private Iterator<org.eclipse.jpt.db.Table> associatedDbTablesIncludingInherited() {
+	protected Iterator<org.eclipse.jpt.db.Table> associatedDbTablesIncludingInherited() {
 		return new FilteringIterator<org.eclipse.jpt.db.Table, org.eclipse.jpt.db.Table>(this.associatedDbTablesIncludingInherited_()) {
 			@Override
 			protected boolean accept(org.eclipse.jpt.db.Table t) {
@@ -366,7 +367,7 @@ public class GenericJavaEntity extends AbstractJavaTypeMapping implements JavaEn
 		};
 	}
 
-	private Iterator<org.eclipse.jpt.db.Table> associatedDbTablesIncludingInherited_() {
+	protected Iterator<org.eclipse.jpt.db.Table> associatedDbTablesIncludingInherited_() {
 		return new TransformationIterator<Table, org.eclipse.jpt.db.Table>(this.associatedTablesIncludingInherited()) {
 			@Override
 			protected org.eclipse.jpt.db.Table transform(Table t) {
@@ -665,11 +666,19 @@ public class GenericJavaEntity extends AbstractJavaTypeMapping implements JavaEn
 		firePropertyChanged(SEQUENCE_GENERATOR_PROPERTY, oldSequenceGenerator, newSequenceGenerator);
 	}
 	
-	@SuppressWarnings("unchecked")
-	protected Iterator<JavaGenerator> generators() {
-		return new CompositeIterator<JavaGenerator>(
-			(getSequenceGenerator() == null) ? EmptyIterator.instance() : new SingleElementIterator(getSequenceGenerator()),
-			(getTableGenerator() == null) ? EmptyIterator.instance() : new SingleElementIterator(getTableGenerator()));
+	public final Iterator<JavaGenerator> generators() {
+		ArrayList<JavaGenerator> generators = new ArrayList<JavaGenerator>();
+		this.addGeneratorsTo(generators);
+		return generators.iterator();
+	}
+
+	protected void addGeneratorsTo(ArrayList<JavaGenerator> generators) {
+		if (this.sequenceGenerator != null) {
+			generators.add(this.sequenceGenerator);
+		}
+		if (this.tableGenerator != null) {
+			generators.add(this.tableGenerator);
+		}
 	}
 
 	public ListIterator<JavaPrimaryKeyJoinColumn> primaryKeyJoinColumns() {
@@ -922,7 +931,7 @@ public class GenericJavaEntity extends AbstractJavaTypeMapping implements JavaEn
 		return containsOverride(name, virtualAssociationOverrides());
 	}
 
-	private BaseOverride getOverrideNamed(String name, ListIterator<? extends BaseOverride> overrides) {
+	protected BaseOverride getOverrideNamed(String name, ListIterator<? extends BaseOverride> overrides) {
 		for (BaseOverride override : CollectionTools.iterable(overrides)) {
 			String overrideName = override.getName();
 			if (overrideName == null && name == null) {
@@ -935,7 +944,7 @@ public class GenericJavaEntity extends AbstractJavaTypeMapping implements JavaEn
 		return null;
 	}
 
-	private boolean containsOverride(String name, ListIterator<? extends BaseOverride> overrides) {
+	protected boolean containsOverride(String name, ListIterator<? extends BaseOverride> overrides) {
 		return getOverrideNamed(name, overrides) != null;
 	}
 
@@ -1150,7 +1159,7 @@ public class GenericJavaEntity extends AbstractJavaTypeMapping implements JavaEn
 	}
 	
 	@SuppressWarnings("unchecked")
-	protected Iterator<JavaQuery> queries() {
+	public Iterator<JavaQuery> queries() {
 		return new CompositeIterator<JavaQuery>(this.namedNativeQueries(), this.namedQueries());
 	}
 
@@ -1851,49 +1860,47 @@ public class GenericJavaEntity extends AbstractJavaTypeMapping implements JavaEn
 	//********** Validation ********************************************
 	
 	@Override
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		super.addToMessages(messages, astRoot);
+	public void validate(List<IMessage> messages, CompilationUnit astRoot) {
+		super.validate(messages, astRoot);
 		
-		getTable().addToMessages(messages, astRoot);
-		addIdMessages(messages, astRoot);
-		addGeneratorMessages(messages, astRoot);
-		addQueryMessages(messages, astRoot);
+		this.table.validate(messages, astRoot);
+		this.validateId(messages, astRoot);
+		this.getPersistenceUnit().validateGenerators(this, messages, astRoot);
+		this.getPersistenceUnit().validateQueries(this, messages, astRoot);
 		
 		for (Iterator<JavaSecondaryTable> stream = this.specifiedSecondaryTables(); stream.hasNext();) {
-			stream.next().addToMessages(messages, astRoot);
+			stream.next().validate(messages, astRoot);
 		}
 
 		for (Iterator<JavaAttributeOverride> stream = this.attributeOverrides(); stream.hasNext();) {
-			stream.next().addToMessages(messages, astRoot);
+			stream.next().validate(messages, astRoot);
 		}
 		
 		for (Iterator<JavaAssociationOverride> stream = this.associationOverrides(); stream.hasNext();) {
-			stream.next().addToMessages(messages, astRoot);
+			stream.next().validate(messages, astRoot);
 		}
 		
 	}
 	
-	protected void addIdMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		addNoIdMessage(messages, astRoot);
-	}
-	
-	protected void addNoIdMessage(List<IMessage> messages, CompilationUnit astRoot) {
-		if (entityHasNoId()) {
+	protected void validateId(List<IMessage> messages, CompilationUnit astRoot) {
+		if (this.entityHasNoId()) {
 			messages.add(
 				DefaultJpaValidationMessages.buildMessage(
 					IMessage.HIGH_SEVERITY,
 					JpaValidationMessages.ENTITY_NO_ID,
 					new String[] {this.getName()},
-					this, this.getValidationTextRange(astRoot))
+					this,
+					this.getValidationTextRange(astRoot)
+				)
 			);
 		}
 	}
 	
-	private boolean entityHasNoId() {
+	protected boolean entityHasNoId() {
 		return ! this.entityHasId();
 	}
 
-	private boolean entityHasId() {
+	protected boolean entityHasId() {
 		for (Iterator<PersistentAttribute> stream = getPersistentType().allAttributes(); stream.hasNext(); ) {
 			if (stream.next().isIdAttribute()) {
 				return true;
@@ -1902,54 +1909,9 @@ public class GenericJavaEntity extends AbstractJavaTypeMapping implements JavaEn
 		return false;
 	}
 	
-	protected void addGeneratorMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		List<Generator> masterList = CollectionTools.list(getPersistenceUnit().allGenerators());
-		
-		for (Iterator<JavaGenerator> stream = this.generators(); stream.hasNext() ; ) {
-			JavaGenerator current = stream.next();
-			masterList.remove(current);
-			
-			for (Generator each : masterList) {
-				if (! each.overrides(current) && each.getName() != null && each.getName().equals(current.getName())) {
-					messages.add(
-						DefaultJpaValidationMessages.buildMessage(
-							IMessage.HIGH_SEVERITY,
-							JpaValidationMessages.GENERATOR_DUPLICATE_NAME,
-							new String[] {current.getName()},
-							current,
-							current.getNameTextRange(astRoot))
-					);
-				}
-			}
-			
-			masterList.add(current);
-		}
-	}
-	
-	protected void addQueryMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		List<Query> masterList = CollectionTools.list(getPersistenceUnit().allQueries());
-		
-		for (Iterator<JavaQuery> stream = this.queries(); stream.hasNext() ; ) {
-			JavaQuery current = stream.next();
-			masterList.remove(current);
-			
-			for (Query each : masterList) {
-				if (! each.overrides(current) && each.getName() != null && each.getName().equals(current.getName())) {
-					messages.add(
-						DefaultJpaValidationMessages.buildMessage(
-							IMessage.HIGH_SEVERITY,
-							JpaValidationMessages.QUERY_DUPLICATE_NAME,
-							new String[] {current.getName()},
-							current,
-							current.getNameTextRange(astRoot))
-					);
-				}
-			}
-			
-			masterList.add(current);
-		}
-	}
-	
+
+	// ********** pk join column owner **********
+
 	class PrimaryKeyJoinColumnOwner implements JavaBaseJoinColumn.Owner
 	{
 		public TextRange getValidationTextRange(CompilationUnit astRoot) {
@@ -1985,6 +1947,9 @@ public class GenericJavaEntity extends AbstractJavaTypeMapping implements JavaEn
 		}
 	}
 	
+
+	// ********** attribute override owner **********
+
 	class AttributeOverrideOwner implements AttributeOverride.Owner {
 
 		public ColumnMapping getColumnMapping(String attributeName) {
@@ -2020,6 +1985,9 @@ public class GenericJavaEntity extends AbstractJavaTypeMapping implements JavaEn
 		}
 	}
 
+
+	// ********** association override owner **********
+
 	class AssociationOverrideOwner implements AssociationOverride.Owner {
 
 		public RelationshipMapping getRelationshipMapping(String attributeName) {
@@ -2054,4 +2022,5 @@ public class GenericJavaEntity extends AbstractJavaTypeMapping implements JavaEn
 			return null;
 		}
 	}
+
 }
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 fee7a4b4e0..0980817d2b 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
@@ -11,6 +11,7 @@ package org.eclipse.jpt.core.internal.context.java;
 
 import java.util.Iterator;
 import java.util.List;
+
 import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.MappingKeys;
 import org.eclipse.jpt.core.context.Converter;
@@ -23,6 +24,7 @@ import org.eclipse.jpt.core.context.java.JavaIdMapping;
 import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;
 import org.eclipse.jpt.core.context.java.JavaSequenceGenerator;
 import org.eclipse.jpt.core.context.java.JavaTableGenerator;
+import org.eclipse.jpt.core.context.persistence.PersistenceUnit;
 import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages;
 import org.eclipse.jpt.core.internal.validation.JpaValidationMessages;
 import org.eclipse.jpt.core.resource.java.ColumnAnnotation;
@@ -34,7 +36,6 @@ import org.eclipse.jpt.core.resource.java.SequenceGeneratorAnnotation;
 import org.eclipse.jpt.core.resource.java.TableGeneratorAnnotation;
 import org.eclipse.jpt.core.resource.java.TemporalAnnotation;
 import org.eclipse.jpt.utility.Filter;
-import org.eclipse.jpt.utility.internal.CollectionTools;
 import org.eclipse.jpt.utility.internal.iterators.ArrayIterator;
 import org.eclipse.jpt.utility.internal.iterators.CompositeIterator;
 import org.eclipse.jpt.utility.internal.iterators.EmptyIterator;
@@ -42,7 +43,9 @@ import org.eclipse.jpt.utility.internal.iterators.SingleElementIterator;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
 
-public class GenericJavaIdMapping extends AbstractJavaAttributeMapping<IdAnnotation> implements JavaIdMapping
+public class GenericJavaIdMapping
+	extends AbstractJavaAttributeMapping<IdAnnotation>
+	implements JavaIdMapping, PersistenceUnit.JavaGeneratorHolder, PersistenceUnit.JavaGeneratedValueHolder
 {
 	protected final JavaColumn column;
 
@@ -138,7 +141,7 @@ public class GenericJavaIdMapping extends AbstractJavaAttributeMapping<IdAnnotat
 	
 	public JavaGeneratedValue addGeneratedValue() {
 		if (getGeneratedValue() != null) {
-			throw new IllegalStateException("gemeratedValue already exists");
+			throw new IllegalStateException("gemeratedValue already exists"); //$NON-NLS-1$
 		}
 		this.generatedValue = getJpaFactory().buildJavaGeneratedValue(this);
 		GeneratedValueAnnotation generatedValueResource = (GeneratedValueAnnotation) getResourcePersistentAttribute().addAnnotation(GeneratedValueAnnotation.ANNOTATION_NAME);
@@ -149,7 +152,7 @@ public class GenericJavaIdMapping extends AbstractJavaAttributeMapping<IdAnnotat
 	
 	public void removeGeneratedValue() {
 		if (getGeneratedValue() == null) {
-			throw new IllegalStateException("gemeratedValue does not exist, cannot be removed");
+			throw new IllegalStateException("gemeratedValue does not exist, cannot be removed"); //$NON-NLS-1$
 		}
 		JavaGeneratedValue oldGeneratedValue = this.generatedValue;
 		this.generatedValue = null;
@@ -169,7 +172,7 @@ public class GenericJavaIdMapping extends AbstractJavaAttributeMapping<IdAnnotat
 
 	public JavaTableGenerator addTableGenerator() {
 		if (getTableGenerator() != null) {
-			throw new IllegalStateException("tableGenerator already exists");
+			throw new IllegalStateException("tableGenerator already exists"); //$NON-NLS-1$
 		}
 		this.tableGenerator = getJpaFactory().buildJavaTableGenerator(this);
 		TableGeneratorAnnotation tableGeneratorResource = (TableGeneratorAnnotation) getResourcePersistentAttribute().addAnnotation(TableGeneratorAnnotation.ANNOTATION_NAME);
@@ -180,7 +183,7 @@ public class GenericJavaIdMapping extends AbstractJavaAttributeMapping<IdAnnotat
 	
 	public void removeTableGenerator() {
 		if (getTableGenerator() == null) {
-			throw new IllegalStateException("tableGenerator does not exist, cannot be removed");
+			throw new IllegalStateException("tableGenerator does not exist, cannot be removed"); //$NON-NLS-1$
 		}
 		JavaTableGenerator oldTableGenerator = this.tableGenerator;
 		this.tableGenerator = null;
@@ -200,7 +203,7 @@ public class GenericJavaIdMapping extends AbstractJavaAttributeMapping<IdAnnotat
 
 	public JavaSequenceGenerator addSequenceGenerator() {
 		if (getSequenceGenerator() != null) {
-			throw new IllegalStateException("sequenceGenerator already exists");
+			throw new IllegalStateException("sequenceGenerator already exists"); //$NON-NLS-1$
 		}
 		
 		this.sequenceGenerator = getJpaFactory().buildJavaSequenceGenerator(this);
@@ -212,7 +215,7 @@ public class GenericJavaIdMapping extends AbstractJavaAttributeMapping<IdAnnotat
 	
 	public void removeSequenceGenerator() {
 		if (getSequenceGenerator() == null) {
-			throw new IllegalStateException("sequenceGenerator does not exist, cannot be removed");
+			throw new IllegalStateException("sequenceGenerator does not exist, cannot be removed"); //$NON-NLS-1$
 		}
 		JavaSequenceGenerator oldSequenceGenerator = this.sequenceGenerator;
 		this.sequenceGenerator = null;
@@ -231,7 +234,7 @@ public class GenericJavaIdMapping extends AbstractJavaAttributeMapping<IdAnnotat
 	}
 	
 	@SuppressWarnings("unchecked")
-	protected Iterator<JavaGenerator> generators() {
+	public Iterator<JavaGenerator> generators() {
 		return new CompositeIterator<JavaGenerator>(
 			(getSequenceGenerator() == null) ? EmptyIterator.instance() : new SingleElementIterator(getSequenceGenerator()),
 			(getTableGenerator() == null) ? EmptyIterator.instance() : new SingleElementIterator(getTableGenerator()));
@@ -314,9 +317,9 @@ public class GenericJavaIdMapping extends AbstractJavaAttributeMapping<IdAnnotat
 	}
 	
 	protected JavaTableGenerator buildTableGenerator(TableGeneratorAnnotation resourceTableGenerator) {
-		JavaTableGenerator tableGenerator = getJpaFactory().buildJavaTableGenerator(this);
-		tableGenerator.initialize(resourceTableGenerator);
-		return tableGenerator;
+		JavaTableGenerator generator = getJpaFactory().buildJavaTableGenerator(this);
+		generator.initialize(resourceTableGenerator);
+		return generator;
 	}
 	
 	protected void updateSequenceGenerator(JavaResourcePersistentAttribute jrpa) {
@@ -337,9 +340,9 @@ public class GenericJavaIdMapping extends AbstractJavaAttributeMapping<IdAnnotat
 	}
 	
 	protected JavaSequenceGenerator buildSequenceGenerator(SequenceGeneratorAnnotation resourceSequenceGenerator) {
-		JavaSequenceGenerator sequenceGenerator = getJpaFactory().buildJavaSequenceGenerator(this);
-		sequenceGenerator.initialize(resourceSequenceGenerator);
-		return sequenceGenerator;
+		JavaSequenceGenerator generator = getJpaFactory().buildJavaSequenceGenerator(this);
+		generator.initialize(resourceSequenceGenerator);
+		return generator;
 	}
 	
 	protected void updateGeneratedValue(JavaResourcePersistentAttribute jrpa) {
@@ -360,9 +363,9 @@ public class GenericJavaIdMapping extends AbstractJavaAttributeMapping<IdAnnotat
 	}
 	
 	protected JavaGeneratedValue buildGeneratedValue(GeneratedValueAnnotation resourceGeneratedValue) {
-		JavaGeneratedValue generatedValue = getJpaFactory().buildJavaGeneratedValue(this);
-		generatedValue.initialize(resourceGeneratedValue);
-		return generatedValue;
+		JavaGeneratedValue gv = getJpaFactory().buildJavaGeneratedValue(this);
+		gv.initialize(resourceGeneratedValue);
+		return gv;
 	}
 
 	protected TableGeneratorAnnotation getResourceTableGenerator(JavaResourcePersistentAttribute jrpa) {
@@ -435,87 +438,41 @@ public class GenericJavaIdMapping extends AbstractJavaAttributeMapping<IdAnnotat
 	//*********** Validation ************
 	
 	@Override
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		super.addToMessages(messages, astRoot);
+	public void validate(List<IMessage> messages, CompilationUnit astRoot) {
+		super.validate(messages, astRoot);
 		
-		if (this.entityOwned() && this.connectionProfileIsActive()) {
-			this.addColumnMessages(messages, astRoot);
+		if (this.ownerIsEntity() && this.connectionProfileIsActive()) {
+			this.validateColumn(messages, astRoot);
 		}
-		addGeneratedValueMessages(messages, astRoot);
-		addGeneratorMessages(messages, astRoot);
+		this.getPersistenceUnit().validateGeneratedValue(this, messages, astRoot);
+		this.getPersistenceUnit().validateGenerators(this, messages, astRoot);
 	}
 		
-	protected void addColumnMessages(List<IMessage> messages, CompilationUnit astRoot) {
+	protected void validateColumn(List<IMessage> messages, CompilationUnit astRoot) {
 		if (this.getTypeMapping().tableNameIsInvalid(this.column.getTable())) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.COLUMN_UNRESOLVED_TABLE,
-						new String[] {this.column.getTable(), this.column.getName()}, 
-						this.column,
-						this.column.getTableTextRange(astRoot))
-				);
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.COLUMN_UNRESOLVED_TABLE,
+					new String[] {this.column.getTable(), this.column.getName()}, 
+					this.column,
+					this.column.getTableTextRange(astRoot)
+				)
+			);
 			return;
 		}
 		
 		if ( ! this.column.isResolved()) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.COLUMN_UNRESOLVED_NAME,
-						new String[] {this.column.getName()}, 
-						this.column,
-						this.column.getNameTextRange(astRoot))
-				);
-		}
-	}
-	
-	protected void addGeneratedValueMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		if (this.generatedValue == null) {
-			return;
-		}
-		String generatorName = this.generatedValue.getGenerator();
-		if (generatorName == null) {
-			return;
-		}
-		
-		for (Generator nextMasterGenerator : CollectionTools.iterable(getPersistenceUnit().allGenerators())) {
-			if (generatorName.equals(nextMasterGenerator.getName())) {
-				return;
-			}
-		}
-		
-		messages.add(
-			DefaultJpaValidationMessages.buildMessage(
-				IMessage.HIGH_SEVERITY,
-				JpaValidationMessages.ID_MAPPING_UNRESOLVED_GENERATOR_NAME,
-				new String[] {generatorName},
-				this,
-				this.generatedValue.getGeneratorTextRange(astRoot))
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.COLUMN_UNRESOLVED_NAME,
+					new String[] {this.column.getName()}, 
+					this.column,
+					this.column.getNameTextRange(astRoot)
+				)
 			);
-	}
-	
-	protected void addGeneratorMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		List<Generator> masterList = CollectionTools.list(getPersistenceUnit().allGenerators());
-		
-		for (Iterator<JavaGenerator> stream = this.generators(); stream.hasNext() ; ) {
-			JavaGenerator current = stream.next();
-			masterList.remove(current);
-			
-			for (Generator each : masterList) {
-				if (! each.overrides(current) && each.getName() != null && each.getName().equals(current.getName())) {
-					messages.add(
-						DefaultJpaValidationMessages.buildMessage(
-							IMessage.HIGH_SEVERITY,
-							JpaValidationMessages.GENERATOR_DUPLICATE_NAME,
-							new String[] {current.getName()},
-							current,
-							current.getNameTextRange(astRoot))
-					);
-				}
-			}
-			
-			masterList.add(current);
 		}
 	}
+	
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaJoinColumn.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaJoinColumn.java
index bd3e29a99f..4260cfb89d 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaJoinColumn.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaJoinColumn.java
@@ -148,42 +148,28 @@ public class GenericJavaJoinColumn extends AbstractJavaBaseColumn<JoinColumnAnno
 	}
 	
 	@Override
-	public void initialize(JoinColumnAnnotation jca) {
-		this.joinColumn = jca;
-		super.initialize(jca);
-		this.specifiedReferencedColumnName = jca.getReferencedColumnName();
-		this.defaultReferencedColumnName = this.defaultReferencedColumnName();
+	public void initialize(JoinColumnAnnotation annotation) {
+		this.joinColumn = annotation;
+		super.initialize(annotation);
+		this.specifiedReferencedColumnName = annotation.getReferencedColumnName();
+		this.defaultReferencedColumnName = this.buildDefaultReferencedColumnName();
 	}
 	
 	@Override
-	public void update(JoinColumnAnnotation jca) {
-		this.joinColumn = jca;
-		super.update(jca);
-		this.setSpecifiedReferencedColumnName_(jca.getReferencedColumnName());
-		this.setDefaultReferencedColumnName(this.defaultReferencedColumnName());
+	public void update(JoinColumnAnnotation annotation) {
+		this.joinColumn = annotation;
+		super.update(annotation);
+		this.setSpecifiedReferencedColumnName_(annotation.getReferencedColumnName());
+		this.setDefaultReferencedColumnName(this.buildDefaultReferencedColumnName());
 	}
 	
 	@Override
 	protected String buildDefaultName() {
-		RelationshipMapping relationshipMapping = getOwner().getRelationshipMapping();
-		if (relationshipMapping == null) {
-			return null;
-		}
-		if (!getOwner().getRelationshipMapping().isRelationshipOwner()) {
-			return null;
-		}
 		return MappingTools.buildJoinColumnDefaultName(this);
 	}
 	
-	protected String defaultReferencedColumnName() {
-		RelationshipMapping relationshipMapping = getOwner().getRelationshipMapping();
-		if (relationshipMapping == null) {
-			return null;
-		}
-		if (!getOwner().getRelationshipMapping().isRelationshipOwner()) {
-			return null;
-		}
-		return MappingTools.buildJoinColumnDefaultReferencedColumnName(this);
+	protected String buildDefaultReferencedColumnName() {
+		return MappingTools.buildJoinColumnDefaultReferencedColumnName(this.getOwner());
 	}
 	
 	@Override
@@ -199,8 +185,8 @@ public class GenericJavaJoinColumn extends AbstractJavaBaseColumn<JoinColumnAnno
 	}
 
 	@Override
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		super.addToMessages(messages, astRoot);
+	public void validate(List<IMessage> messages, CompilationUnit astRoot) {
+		super.validate(messages, astRoot);
 		if ( ! this.isResolved()) {
 			messages.add(
 				DefaultJpaValidationMessages.buildMessage(
@@ -208,7 +194,8 @@ public class GenericJavaJoinColumn extends AbstractJavaBaseColumn<JoinColumnAnno
 					JpaValidationMessages.JOIN_COLUMN_UNRESOLVED_NAME,
 					new String[] {this.getName()}, 
 					this,
-					this.getNameTextRange(astRoot))
+					this.getNameTextRange(astRoot)
+				)
 			);
 		}
 
@@ -219,7 +206,8 @@ public class GenericJavaJoinColumn extends AbstractJavaBaseColumn<JoinColumnAnno
 					JpaValidationMessages.JOIN_COLUMN_REFERENCED_COLUMN_UNRESOLVED_NAME,
 					new String[] {this.getReferencedColumnName(), this.getName()}, 
 					this,
-					this.getReferencedColumnNameTextRange(astRoot))
+					this.getReferencedColumnNameTextRange(astRoot)
+				)
 			);
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaJoinTable.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaJoinTable.java
index a0c6568e3a..1a61537425 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaJoinTable.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaJoinTable.java
@@ -501,39 +501,41 @@ public class GenericJavaJoinTable
 		return joinColumn;
 	}
 
-	
-	//********************* validation ********************
+
+	// ********** validation **********
 	
 	@Override
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		super.addToMessages(messages, astRoot);
+	public void validate(List<IMessage> messages, CompilationUnit astRoot) {
+		super.validate(messages, astRoot);
 		if (this.connectionProfileIsActive()) {
-			this.checkDatabase(messages, astRoot);
+			this.validateAgainstDatabase(messages, astRoot);
 		}
 	}
 
-	protected void checkDatabase(List<IMessage> messages, CompilationUnit astRoot) {
+	protected void validateAgainstDatabase(List<IMessage> messages, CompilationUnit astRoot) {
 		if ( ! this.hasResolvedCatalog()) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.JOIN_TABLE_UNRESOLVED_CATALOG,
-						new String[] {this.getCatalog(), this.getName()}, 
-						this, 
-						this.getCatalogTextRange(astRoot))
-				);
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.JOIN_TABLE_UNRESOLVED_CATALOG,
+					new String[] {this.getCatalog(), this.getName()}, 
+					this, 
+					this.getCatalogTextRange(astRoot)
+				)
+			);
 			return;
 		}
 		
 		if ( ! this.hasResolvedSchema()) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.JOIN_TABLE_UNRESOLVED_SCHEMA,
-						new String[] {this.getSchema(), this.getName()}, 
-						this, 
-						this.getSchemaTextRange(astRoot))
-				);
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.JOIN_TABLE_UNRESOLVED_SCHEMA,
+					new String[] {this.getSchema(), this.getName()}, 
+					this, 
+					this.getSchemaTextRange(astRoot)
+				)
+			);
 			return;
 		}
 		
@@ -541,25 +543,29 @@ public class GenericJavaJoinTable
 			String attributeName = this.getRelationshipMapping().getPersistentAttribute().getName();
 			messages.add(
 				DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.JOIN_TABLE_CANNOT_BE_DETERMINED,
-						new String[] {attributeName}, 
-						this, 
-						this.getNameTextRange(astRoot))
-				);
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.JOIN_TABLE_CANNOT_BE_DETERMINED,
+					new String[] {attributeName},
+					this,
+					this.getNameTextRange(astRoot)
+				)
+			);
 			return;
 		}
 		
-		this.checkJoinColumns(this.joinColumns(), messages, astRoot);
-		this.checkJoinColumns(this.inverseJoinColumns(), messages, astRoot);
+		this.validateJoinColumns(this.joinColumns(), messages, astRoot);
+		this.validateJoinColumns(this.inverseJoinColumns(), messages, astRoot);
 	}		
 
-	protected void checkJoinColumns(Iterator<JavaJoinColumn> joinColumns, List<IMessage> messages, CompilationUnit astRoot) {
+	protected void validateJoinColumns(Iterator<JavaJoinColumn> joinColumns, List<IMessage> messages, CompilationUnit astRoot) {
 		while (joinColumns.hasNext()) {
-			joinColumns.next().addToMessages(messages, astRoot);
+			joinColumns.next().validate(messages, astRoot);
 		}
 	}
 
+
+	// ********** join column owner adapters **********
+	
 	/**
 	 * just a little common behavior
 	 */
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 d167f24d6d..df07fc3570 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
@@ -77,7 +77,7 @@ public class GenericJavaManyToManyMapping extends AbstractJavaMultiRelationshipM
 	}
 	
 	@Override
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		super.addToMessages(messages, astRoot);
+	public void validate(List<IMessage> messages, CompilationUnit astRoot) {
+		super.validate(messages, astRoot);
 	}
 }
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 c6a2569169..acb5583cbf 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
@@ -69,8 +69,8 @@ public class GenericJavaManyToOneMapping
 	}
 
 	@Override
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		super.addToMessages(messages, astRoot);
+	public void validate(List<IMessage> messages, CompilationUnit astRoot) {
+		super.validate(messages, astRoot);
 	}
 
 }
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 247c3f2264..c3c43657ed 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
@@ -44,7 +44,7 @@ public class GenericJavaNullAttributeMapping extends AbstractJavaAttributeMappin
 	}
 	
 	@Override
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		super.addToMessages(messages, astRoot);
+	public void validate(List<IMessage> messages, CompilationUnit astRoot) {
+		super.validate(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 a1bf58e188..7858eb3ec0 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
@@ -79,8 +79,8 @@ public class GenericJavaOneToManyMapping extends AbstractJavaMultiRelationshipMa
 	}
 	
 	@Override
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		super.addToMessages(messages, astRoot);
+	public void validate(List<IMessage> messages, CompilationUnit astRoot) {
+		super.validate(messages, astRoot);
 	}
 	
 }
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 97c65c01cb..00d6c3498e 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
@@ -260,67 +260,66 @@ public class GenericJavaOneToOneMapping
 	// ********** Validation **********
 
 	@Override
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		super.addToMessages(messages, astRoot);
+	public void validate(List<IMessage> messages, CompilationUnit astRoot) {
+		super.validate(messages, astRoot);
 		
 		if (this.mappedBy != null) {
-			this.checkMappedBy(messages ,astRoot);
+			this.validateMappedBy(messages ,astRoot);
 		}
 	}
 
 	@Override
-	protected void checkJoinColumns(List<IMessage> messages, CompilationUnit astRoot) {
+	protected void validateJoinColumns(List<IMessage> messages, CompilationUnit astRoot) {
 		if (this.primaryKeyJoinColumns.isEmpty() || this.containsSpecifiedJoinColumns()) {
-			super.checkJoinColumns(messages, astRoot);
+			super.validateJoinColumns(messages, astRoot);
 		}
 	}
 
-	protected void checkMappedBy(List<IMessage> messages, CompilationUnit astRoot) {
+	protected void validateMappedBy(List<IMessage> messages, CompilationUnit astRoot) {
 		Entity targetEntity = this.getResolvedTargetEntity();
 		if (targetEntity == null) {
-			// already have validation messages for that
-			return;
+			return;  // null target entity is validated elsewhere
 		}
 		
 		PersistentAttribute attribute = targetEntity.getPersistentType().resolveAttribute(this.mappedBy);
 		
 		if (attribute == null) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.MAPPING_UNRESOLVED_MAPPED_BY,
-						new String[] {this.mappedBy},
-						this,
-						this.getMappedByTextRange(astRoot)
-					)
-				);
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.MAPPING_UNRESOLVED_MAPPED_BY,
+					new String[] {this.mappedBy},
+					this,
+					this.getMappedByTextRange(astRoot)
+				)
+			);
 			return;
 		}
 		
-		if ( ! this.mappedByIsValid(attribute.getMapping())) {
+		AttributeMapping mappedByMapping = attribute.getMapping();
+		if ( ! this.mappedByIsValid(mappedByMapping)) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.MAPPING_INVALID_MAPPED_BY,
-						new String[] {this.mappedBy}, 
-						this,
-						this.getMappedByTextRange(astRoot)
-					)
-				);
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.MAPPING_INVALID_MAPPED_BY,
+					new String[] {this.mappedBy}, 
+					this,
+					this.getMappedByTextRange(astRoot)
+				)
+			);
 			return;
 		}
 		
-		AttributeMapping mappedByMapping = attribute.getMapping();
 		if ((mappedByMapping instanceof NonOwningMapping)
 				&& ((NonOwningMapping) mappedByMapping).getMappedBy() != null) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.MAPPING_MAPPED_BY_ON_BOTH_SIDES,
-						this,
-						this.getMappedByTextRange(astRoot)
-					)
-				);
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.MAPPING_MAPPED_BY_ON_BOTH_SIDES,
+					this,
+					this.getMappedByTextRange(astRoot)
+				)
+			);
 		}
 	}
 
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 9e80466e0c..c88db4a8c3 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
@@ -29,7 +29,11 @@ import org.eclipse.jpt.utility.Filter;
 import org.eclipse.jpt.utility.internal.CollectionTools;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
-public class GenericJavaPersistentAttribute extends AbstractJavaJpaContextNode
+/**
+ * 
+ */
+public class GenericJavaPersistentAttribute
+	extends AbstractJavaJpaContextNode
 	implements JavaPersistentAttribute
 {
 	protected String name;
@@ -40,6 +44,7 @@ public class GenericJavaPersistentAttribute extends AbstractJavaJpaContextNode
 
 	protected JavaResourcePersistentAttribute resourcePersistentAttribute;
 
+
 	public GenericJavaPersistentAttribute(JavaPersistentType parent, JavaResourcePersistentAttribute jrpa) {
 		super(parent);
 		this.initialize(jrpa);
@@ -301,28 +306,33 @@ public class GenericJavaPersistentAttribute extends AbstractJavaJpaContextNode
 		}
 		return this.getMapping().javaCompletionProposals(pos, filter, astRoot);
 	}
-	
-	//************* Validation ******************************
-	
+
+
+	// ********** validation **********
+
 	@Override
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		super.addToMessages(messages, astRoot);
+	public void validate(List<IMessage> messages, CompilationUnit astRoot) {
+		super.validate(messages, astRoot);
 		
 		if (this.specifiedMapping != null) {
-			this.specifiedMapping.addToMessages(messages, astRoot);
+			this.specifiedMapping.validate(messages, astRoot);
 		}
 		else if (this.defaultMapping != null) {
-			this.defaultMapping.addToMessages(messages, astRoot);
+			this.defaultMapping.validate(messages, astRoot);
 		}
 	}
 	
+
+	// ********** misc **********
+
 	@Override
 	public void toString(StringBuilder sb) {
 		super.toString(sb);
-		sb.append(getName());
+		sb.append(this.name);
 	}
 	
 	public void dispose() {
 		//nothing to dispose
 	}
+
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaPersistentType.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaPersistentType.java
index b66a329fdf..77846f0b45 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaPersistentType.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaPersistentType.java
@@ -507,36 +507,50 @@ public class GenericJavaPersistentType extends AbstractJavaJpaContextNode implem
 		return getPersistenceUnit().getPersistentType(fullyQualifiedTypeName);
 	}
 
-	//*************** Validation ******************************************
-	public void addToMessages(List<IMessage> messages) {
-		//get astRoot here to pass down
-		addToMessages(messages, this.buildASTRoot());	
+
+	// ********** validation **********
+
+	public void validate(List<IMessage> messages) {
+		// build the AST root here to pass down
+		this.validate(messages, this.buildASTRoot());	
 	}
 	
 	@Override
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
+	public void validate(List<IMessage> messages, CompilationUnit astRoot) {
+		super.validate(messages, astRoot);
+		this.validateMapping(messages, astRoot);
+		this.validateAttributes(messages, astRoot);
+	}
+	
+	protected void validateMapping(List<IMessage> messages, CompilationUnit astRoot) {
 		try {
-			this.mapping.addToMessages(messages, astRoot);
+			this.mapping.validate(messages, astRoot);
 		} catch(Throwable t) {
 			JptCorePlugin.log(t);
 		}
-		addAttributeMessages(messages, astRoot);
 	}
 	
-	protected void addAttributeMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		for (JavaPersistentAttribute persistentAttribute : this.attributes) {
-			try {
-				persistentAttribute.addToMessages(messages, astRoot);
-			} catch(Throwable t) {
-				JptCorePlugin.log(t);
-			}
+	protected void validateAttributes(List<IMessage> messages, CompilationUnit astRoot) {
+		for (Iterator<JavaPersistentAttribute> stream = this.attributes(); stream.hasNext(); ) {
+			this.validateAttribute(stream.next(), messages, astRoot);
 		}
 	}
 	
+	protected void validateAttribute(JavaPersistentAttribute attribute, List<IMessage> messages, CompilationUnit astRoot) {
+		try {
+			attribute.validate(messages, astRoot);
+		} catch(Throwable t) {
+			JptCorePlugin.log(t);
+		}
+	}
+	
+
+	// ********** misc **********
+
 	@Override
 	public void toString(StringBuilder sb) {
 		super.toString(sb);
-		sb.append(getName());
+		sb.append(this.name);
 	}
 
 	public void dispose() {
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaSecondaryTable.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaSecondaryTable.java
index 874026fd24..e27eb22db4 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaSecondaryTable.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaSecondaryTable.java
@@ -274,57 +274,63 @@ public class GenericJavaSecondaryTable
 		return new PrimaryKeyJoinColumnOwner();
 	}
 	
+
+	// ********** validation **********
+
 	@Override
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		super.addToMessages(messages, astRoot);
+	public void validate(List<IMessage> messages, CompilationUnit astRoot) {
+		super.validate(messages, astRoot);
 		if (this.connectionProfileIsActive()) {
-			this.checkDatabase(messages, astRoot);
+			this.validateAgainstDatabase(messages, astRoot);
 		}
 		for (Iterator<JavaPrimaryKeyJoinColumn> stream = this.primaryKeyJoinColumns(); stream.hasNext(); ) {
-			stream.next().addToMessages(messages, astRoot);
+			stream.next().validate(messages, astRoot);
 		}
 	}
 
-	protected void checkDatabase(List<IMessage> messages, CompilationUnit astRoot) {
+	protected void validateAgainstDatabase(List<IMessage> messages, CompilationUnit astRoot) {
 		if ( ! this.hasResolvedCatalog()) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.SECONDARY_TABLE_UNRESOLVED_CATALOG,
-						new String[] {this.getCatalog(), this.getName()}, 
-						this, 
-						this.getCatalogTextRange(astRoot))
-				);
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.SECONDARY_TABLE_UNRESOLVED_CATALOG,
+					new String[] {this.getCatalog(), this.getName()}, 
+					this, 
+					this.getCatalogTextRange(astRoot)
+				)
+			);
 			return;
 		}
 		
 		if ( ! this.hasResolvedSchema()) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.SECONDARY_TABLE_UNRESOLVED_SCHEMA,
-						new String[] {this.getSchema(), this.getName()}, 
-						this, 
-						this.getSchemaTextRange(astRoot))
-				);
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.SECONDARY_TABLE_UNRESOLVED_SCHEMA,
+					new String[] {this.getSchema(), this.getName()}, 
+					this, 
+					this.getSchemaTextRange(astRoot)
+				)
+			);
 			return;
 		}
 		
 		if ( ! this.isResolved()) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.SECONDARY_TABLE_UNRESOLVED_NAME,
-						new String[] {this.getName()}, 
-						this, 
-						this.getNameTextRange(astRoot))
-				);
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.SECONDARY_TABLE_UNRESOLVED_NAME,
+					new String[] {this.getName()}, 
+					this, 
+					this.getNameTextRange(astRoot)
+				)
+			);
 			return;
 		}
 	}
 
 
-	//********************* code completion ************************
+	// ********** code completion **********
 
 	@Override
 	public Iterator<String> javaCompletionProposals(int pos, Filter<String> filter, CompilationUnit astRoot) {
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaTable.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaTable.java
index 9ca644deaa..d07923e75a 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaTable.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaTable.java
@@ -100,48 +100,50 @@ public class GenericJavaTable
 	//******************* validation **********************
 	
 	@Override
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		super.addToMessages(messages, astRoot);
+	public void validate(List<IMessage> messages, CompilationUnit astRoot) {
+		super.validate(messages, astRoot);
 		if (this.connectionProfileIsActive()) {
-			this.checkDatabase(messages, astRoot);
+			this.validateAgainstDatabase(messages, astRoot);
 		}
 	}
 
-	protected void checkDatabase(List<IMessage> messages, CompilationUnit astRoot) {
+	protected void validateAgainstDatabase(List<IMessage> messages, CompilationUnit astRoot) {
 		if ( ! this.hasResolvedCatalog()) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.TABLE_UNRESOLVED_CATALOG,
-						new String[] {this.getCatalog(), this.getName()}, 
-						this, 
-						this.getCatalogTextRange(astRoot))
-				);
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.TABLE_UNRESOLVED_CATALOG,
+					new String[] {this.getCatalog(), this.getName()}, 
+					this, 
+					this.getCatalogTextRange(astRoot)
+				)
+			);
 			return;
 		}
 		
 		if ( ! this.hasResolvedSchema()) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.TABLE_UNRESOLVED_SCHEMA,
-						new String[] {this.getSchema(), this.getName()}, 
-						this, 
-						this.getSchemaTextRange(astRoot))
-				);
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.TABLE_UNRESOLVED_SCHEMA,
+					new String[] {this.getSchema(), this.getName()}, 
+					this, 
+					this.getSchemaTextRange(astRoot)
+				)
+			);
 			return;
 		}
 		
 		if ( ! this.isResolved()) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.TABLE_UNRESOLVED_NAME,
-						new String[] {this.getName()}, 
-						this, 
-						this.getNameTextRange(astRoot))
-				);
-			return;
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.TABLE_UNRESOLVED_NAME,
+					new String[] {this.getName()}, 
+					this, 
+					this.getNameTextRange(astRoot)
+				)
+			);
 		}
 	}
 
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 d7d919db68..05004e1822 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
@@ -40,8 +40,8 @@ public class GenericJavaTransientMapping extends AbstractJavaAttributeMapping<Tr
 	}
 
 	@Override
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		super.addToMessages(messages, astRoot);
+	public void validate(List<IMessage> messages, CompilationUnit astRoot) {
+		super.validate(messages, astRoot);
 	}
 	
 }
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 b4f88454e2..f7afd9598b 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
@@ -177,35 +177,38 @@ public class GenericJavaVersionMapping extends AbstractJavaAttributeMapping<Vers
 	//***********  Validation  ******************************
 	
 	@Override
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		super.addToMessages(messages, astRoot);
-		if (this.entityOwned() && this.connectionProfileIsActive()) {
-			this.addColumnMessages(messages, astRoot);
+	public void validate(List<IMessage> messages, CompilationUnit astRoot) {
+		super.validate(messages, astRoot);
+		if (this.ownerIsEntity() && this.connectionProfileIsActive()) {
+			this.validateColumn(messages, astRoot);
 		}
 	}
 	
-	protected void addColumnMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		if (this.getTypeMapping().tableNameIsInvalid(this.column.getTable())) {
+	protected void validateColumn(List<IMessage> messages, CompilationUnit astRoot) {
+		String tableName = this.column.getTable();
+		if (this.getTypeMapping().tableNameIsInvalid(tableName)) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.COLUMN_UNRESOLVED_TABLE,
-						new String[] {this.column.getTable(), this.column.getName()}, 
-						this.column,
-						this.column.getTableTextRange(astRoot))
-				);
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.COLUMN_UNRESOLVED_TABLE,
+					new String[] {tableName, this.column.getName()}, 
+					this.column,
+					this.column.getTableTextRange(astRoot)
+				)
+			);
 			return;
 		}
 		
 		if ( ! this.column.isResolved()) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.COLUMN_UNRESOLVED_NAME,
-						new String[] {this.column.getName()}, 
-						this.column,
-						this.column.getNameTextRange(astRoot))
-				);
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.COLUMN_UNRESOLVED_NAME,
+					new String[] {this.column.getName()}, 
+					this.column,
+					this.column.getNameTextRange(astRoot)
+				)
+			);
 		}
 	}
 	
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaNullTypeMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaNullTypeMapping.java
index b3067e7e93..8445bb0e91 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaNullTypeMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaNullTypeMapping.java
@@ -42,19 +42,26 @@ public class JavaNullTypeMapping extends AbstractJavaTypeMapping
 	public Iterator<String> correspondingAnnotationNames() {
 		return EmptyIterator.instance();
 	}
-	
+
+	/**
+	 * We added this message here because the most likely solution is to add
+	 * an annotation to the .java file.
+	 * This message used to be found on the <class> tag in persistence.xml.
+	 * The other possible way to fix the error is to remove it from persistence.xml.
+	 * This can be accomplished with the Synchronize Classes action.
+	 * We could also add a quick fix for this error.
+	 */
 	@Override
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		//Adding this message here because the likely solution is to add an annotation to the java file.
-		//This message used to be found on the <class> tag in the persistence.xml.  The other possible
-		//way to fix the error is to remove it from the persistnce.xml.  This can be accomplished
-		//with the Synchronize Classes action.  We could also add a quick fix for this error.
-		messages.add(DefaultJpaValidationMessages.buildMessage(
-			IMessage.HIGH_SEVERITY,
-			JpaValidationMessages.PERSISTENCE_UNIT_INVALID_CLASS,
-			new String[] { this.getPersistentType().getName() },
-			this,
-			this.getValidationTextRange(astRoot)));
+	public void validate(List<IMessage> messages, CompilationUnit astRoot) {
+		messages.add(
+			DefaultJpaValidationMessages.buildMessage(
+				IMessage.HIGH_SEVERITY,
+				JpaValidationMessages.PERSISTENCE_UNIT_INVALID_CLASS,
+				new String[] {this.getPersistentType().getName()},
+				this,
+				this.getValidationTextRange(astRoot)
+			)
+		);
 	}
 	
 	@Override
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmAttributeMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmAttributeMapping.java
index 97cad49cb5..51e136aadc 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmAttributeMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmAttributeMapping.java
@@ -216,7 +216,7 @@ public abstract class AbstractOrmAttributeMapping<T extends XmlAttributeMapping>
 	}
 	
 	
-	protected boolean entityOwned() {
+	protected boolean ownerIsEntity() {
 		return getTypeMapping().getKey() == MappingKeys.ENTITY_TYPE_MAPPING_KEY;
 	}
 
@@ -240,15 +240,15 @@ public abstract class AbstractOrmAttributeMapping<T extends XmlAttributeMapping>
 	// ********** validation **********
 
 	@Override
-	public void addToMessages(List<IMessage> messages) {
-		super.addToMessages(messages);
-		this.checkAttribute(messages);
-		this.checkModifiers(messages);
-		this.checkMapping(messages);
+	public void validate(List<IMessage> messages) {
+		super.validate(messages);
+		this.validateAttribute(messages);
+		this.validateModifiers(messages);
+		this.validateMapping(messages);
 	}
 	
-	protected void checkAttribute(List<IMessage> messages) {
-		if (StringTools.stringIsEmpty(this.getName())) {
+	protected void validateAttribute(List<IMessage> messages) {
+		if (StringTools.stringIsEmpty(this.name)) {
 			messages.add(
 				DefaultJpaValidationMessages.buildMessage(
 					IMessage.HIGH_SEVERITY,
@@ -265,7 +265,7 @@ public abstract class AbstractOrmAttributeMapping<T extends XmlAttributeMapping>
 				DefaultJpaValidationMessages.buildMessage(
 					IMessage.HIGH_SEVERITY,
 					JpaValidationMessages.PERSISTENT_ATTRIBUTE_UNRESOLVED_NAME,
-					new String[] {this.getName(), this.getPersistentAttribute().getPersistentType().getMapping().getClass_()},
+					new String[] {this.name, this.getPersistentAttribute().getPersistentType().getMapping().getClass_()},
 					this, 
 					this.getNameTextRange()
 				)
@@ -273,7 +273,7 @@ public abstract class AbstractOrmAttributeMapping<T extends XmlAttributeMapping>
 		}
 	}
 	
-	protected void checkModifiers(List<IMessage> messages) {
+	protected void validateModifiers(List<IMessage> messages) {
 		if (this.getKey() == MappingKeys.TRANSIENT_ATTRIBUTE_MAPPING_KEY) {
 			return;
 		}
@@ -284,43 +284,37 @@ public abstract class AbstractOrmAttributeMapping<T extends XmlAttributeMapping>
 		JavaResourcePersistentAttribute jrpa = jpa.getResourcePersistentAttribute();
 
 		if (jrpa.isForField()) {
-			//TODO validation : need to have a validation message for final methods as well.
-			//From the JPA spec : No methods or persistent instance variables of the entity class may be final.
 			if (jrpa.isFinal()) {
-				messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.PERSISTENT_ATTRIBUTE_FINAL_FIELD,
-						new String[] {this.getName()},
-						this.getPersistentAttribute(),
-						this.getPersistentAttribute().getValidationTextRange()
-					)
-				);
+				messages.add(this.buildAttributeMessage(JpaValidationMessages.PERSISTENT_ATTRIBUTE_FINAL_FIELD));
 			}
-			
 			if (jrpa.isPublic()) {
-				messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.PERSISTENT_ATTRIBUTE_PUBLIC_FIELD,
-						new String[] {this.getName()},
-						this.getPersistentAttribute(), 
-						this.getPersistentAttribute().getValidationTextRange()
-					)
-				);
-				
+				messages.add(this.buildAttributeMessage(JpaValidationMessages.PERSISTENT_ATTRIBUTE_PUBLIC_FIELD));
 			}
+		} else {
+			//TODO validation : need to have a validation message for final methods as well.
+			//From the JPA spec : No methods or persistent instance variables of the entity class may be final.
 		}
 	}
 
+	protected IMessage buildAttributeMessage(String msgID) {
+		OrmPersistentAttribute pa = this.getPersistentAttribute();
+		return DefaultJpaValidationMessages.buildMessage(
+			IMessage.HIGH_SEVERITY,
+			msgID,
+			new String[] {this.name},
+			pa, 
+			pa.getValidationTextRange()
+		);
+	}
+
 	//TODO validation message - i think more info is needed in this message.  include type mapping type?
-	protected void checkMapping(List<IMessage> messages) {
+	protected void validateMapping(List<IMessage> messages) {
 		if ( ! this.getTypeMapping().attributeMappingKeyAllowed(this.getKey())) {
 			messages.add(
 				DefaultJpaValidationMessages.buildMessage(
 					IMessage.HIGH_SEVERITY,
 					JpaValidationMessages.PERSISTENT_ATTRIBUTE_INVALID_MAPPING,
-					new String[] {this.getName()},
+					new String[] {this.name},
 					this, 
 					this.getValidationTextRange()
 				)
@@ -328,4 +322,9 @@ public abstract class AbstractOrmAttributeMapping<T extends XmlAttributeMapping>
 		}
 	}
 	
+	@Override
+	public void toString(StringBuilder sb) {
+		sb.append(this.getAttributeName());
+	}
+
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmJpaContextNode.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmJpaContextNode.java
index 22f59c6274..81d1bd36c8 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmJpaContextNode.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmJpaContextNode.java
@@ -34,7 +34,7 @@ public abstract class AbstractOrmJpaContextNode
 	 * All subclass implementations {@link #addToMessages(List<IMessage>)} 
 	 * should be preceded by a "super" call to this method
 	 */
-	public void addToMessages(List<IMessage> messages) {
+	public void validate(List<IMessage> messages) {
 		// do nothing by default
 	}
 
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmMultiRelationshipMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmMultiRelationshipMapping.java
index 0c7c7012fa..465a8f26bc 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmMultiRelationshipMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmMultiRelationshipMapping.java
@@ -13,6 +13,7 @@ import java.util.Iterator;
 import java.util.List;
 
 import org.eclipse.jpt.core.context.AttributeMapping;
+import org.eclipse.jpt.core.context.Entity;
 import org.eclipse.jpt.core.context.FetchType;
 import org.eclipse.jpt.core.context.MultiRelationshipMapping;
 import org.eclipse.jpt.core.context.NonOwningMapping;
@@ -129,7 +130,7 @@ public abstract class AbstractOrmMultiRelationshipMapping<T extends XmlMultiRela
 		boolean oldPkOrdering = this.isPkOrdering;
 		this.isPkOrdering = newPkOrdering;
 		if (newPkOrdering) {
-			getAttributeMapping().setOrderBy("");
+			getAttributeMapping().setOrderBy(""); //$NON-NLS-1$
 		}
 		firePropertyChanged(PK_ORDERING_PROPERTY, oldPkOrdering, newPkOrdering);	
 	}
@@ -148,7 +149,7 @@ public abstract class AbstractOrmMultiRelationshipMapping<T extends XmlMultiRela
 		boolean oldCustomOrdering = this.isCustomOrdering;
 		this.isCustomOrdering = newCustomOrdering;
 		if (newCustomOrdering) {
-			setOrderBy("");
+			setOrderBy(""); //$NON-NLS-1$
 		}
 		firePropertyChanged(CUSTOM_ORDERING_PROPERTY, oldCustomOrdering, newCustomOrdering);
 	}
@@ -163,7 +164,7 @@ public abstract class AbstractOrmMultiRelationshipMapping<T extends XmlMultiRela
 		return this.joinTable;
 	}
 
-	public boolean isJoinTableSpecified() {
+	public boolean joinTableIsSpecified() {
 		return getJoinTable().isSpecified();
 	}
 
@@ -302,70 +303,71 @@ public abstract class AbstractOrmMultiRelationshipMapping<T extends XmlMultiRela
 	//****************** validation ******************8
 	
 	@Override
-	public void addToMessages(List<IMessage> messages) {
-		super.addToMessages(messages);
-		
-		if (entityOwned() && (this.isJoinTableSpecified() || isRelationshipOwner())) {
-			getJoinTable().addToMessages(messages);
+	public void validate(List<IMessage> messages) {
+		super.validate(messages);
+		if (this.ownerIsEntity() && (this.joinTableIsSpecified() || this.isRelationshipOwner())) {
+			this.joinTable.validate(messages);
 		}
-		if (getMappedBy() != null) {
-			addMappedByMessages(messages);
+		if (this.mappedBy != null) {
+			this.validateMappedBy(messages);
 		}
 	}
 	
-	protected void addMappedByMessages(List<IMessage> messages) {	
-		if (isJoinTableSpecified()) {
+	protected void validateMappedBy(List<IMessage> messages) {	
+		if (this.joinTableIsSpecified()) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.MAPPING_MAPPED_BY_WITH_JOIN_TABLE,
-						getJoinTable(),
-						getJoinTable().getValidationTextRange())
-				);
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.MAPPING_MAPPED_BY_WITH_JOIN_TABLE,
+					this.joinTable,
+					this.joinTable.getValidationTextRange()
+				)
+			);
 		}
-		
-		if (getResolvedTargetEntity() == null) {
-			// already have validation messages for that
-			return;
+		Entity targetEntity = this.getResolvedTargetEntity();
+		if (targetEntity == null) {
+			return;  // validated elsewhere
 		}
 		
-		PersistentAttribute attribute = getResolvedTargetEntity().getPersistentType().resolveAttribute(getMappedBy());
+		PersistentAttribute attribute = targetEntity.getPersistentType().resolveAttribute(this.mappedBy);
 		
 		if (attribute == null) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.MAPPING_UNRESOLVED_MAPPED_BY,
-						new String[] {getMappedBy()}, 
-						this,
-						getMappedByTextRange())
-				);
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.MAPPING_UNRESOLVED_MAPPED_BY,
+					new String[] {this.mappedBy}, 
+					this,
+					this.getMappedByTextRange()
+				)
+			);
 			return;
 		}
 		
-		if (! mappedByIsValid(attribute.getMapping())) {
+		AttributeMapping mappedByMapping = attribute.getMapping();
+		if ( ! this.mappedByIsValid(mappedByMapping)) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.MAPPING_INVALID_MAPPED_BY,
-						new String[] {getMappedBy()}, 
-						this,
-						getMappedByTextRange())
-				);
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.MAPPING_INVALID_MAPPED_BY,
+					new String[] {this.mappedBy}, 
+					this,
+					this.getMappedByTextRange()
+				)
+			);
 			return;
 		}
 		
-		AttributeMapping mappedByMapping = attribute.getMapping();
 		if ((mappedByMapping instanceof NonOwningMapping)
 				&& ((NonOwningMapping) mappedByMapping).getMappedBy() != null) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.MAPPING_MAPPED_BY_ON_BOTH_SIDES,
-						this,
-						getMappedByTextRange()
-					)
-				);
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.MAPPING_MAPPED_BY_ON_BOTH_SIDES,
+					this,
+					this.getMappedByTextRange()
+				)
+			);
 		}
 	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmSingleRelationshipMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmSingleRelationshipMapping.java
index 10041beb72..81e2761160 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmSingleRelationshipMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmSingleRelationshipMapping.java
@@ -301,11 +301,10 @@ public abstract class AbstractOrmSingleRelationshipMapping<T extends XmlSingleRe
 	// ********** validation **********
 
 	@Override
-	public void addToMessages(List<IMessage> messages) {
-		super.addToMessages(messages);
-		
+	public void validate(List<IMessage> messages) {
+		super.validate(messages);
 		if (this.connectionProfileIsActive()) {
-			this.checkJoinColumns(messages);
+			this.validateJoinColumns(messages);
 		}
 	}
 	
@@ -313,33 +312,33 @@ public abstract class AbstractOrmSingleRelationshipMapping<T extends XmlSingleRe
 	//of a bidirectional relationship.  This is a low risk fix for RC3, but a better
 	//solution would be to not have the default joinColumns on the non-owning side.
 	//This would fix another bug that we show default joinColumns in this situation.
-	protected void checkJoinColumns(List<IMessage> messages) {
-		if (this.entityOwned() && this.isRelationshipOwner()) {
+	protected void validateJoinColumns(List<IMessage> messages) {
+		if (this.ownerIsEntity() && this.isRelationshipOwner()) {
 			for (Iterator<OrmJoinColumn> stream = this.joinColumns(); stream.hasNext(); ) {
-				this.checkJoinColumn(stream.next(), messages);
+				this.validateJoinColumn(stream.next(), messages);
 			}
 		}
 	}
 
-	protected void checkJoinColumn(OrmJoinColumn joinColumn, List<IMessage> messages) {
-		if (this.getTypeMapping().tableNameIsInvalid(joinColumn.getTable())) {
+	protected void validateJoinColumn(OrmJoinColumn joinColumn, List<IMessage> messages) {
+		String tableName = joinColumn.getTable();
+		if (this.getTypeMapping().tableNameIsInvalid(tableName)) {
 			if (this.getPersistentAttribute().isVirtual()) {
 				messages.add(
 					DefaultJpaValidationMessages.buildMessage(
 						IMessage.HIGH_SEVERITY,
 						JpaValidationMessages.VIRTUAL_ATTRIBUTE_JOIN_COLUMN_UNRESOLVED_TABLE,
-						new String[] {this.getName(), joinColumn.getTable(), joinColumn.getName()},
+						new String[] {this.getName(), tableName, joinColumn.getName()},
 						joinColumn,
 						joinColumn.getTableTextRange()
 					)
 				);
-			}
-			else {
+			} else {
 				messages.add(
 					DefaultJpaValidationMessages.buildMessage(
 						IMessage.HIGH_SEVERITY,
 						JpaValidationMessages.JOIN_COLUMN_UNRESOLVED_TABLE,
-						new String[] {joinColumn.getTable(), joinColumn.getName()}, 
+						new String[] {tableName, joinColumn.getName()}, 
 						joinColumn, 
 						joinColumn.getTableTextRange()
 					)
@@ -359,8 +358,7 @@ public abstract class AbstractOrmSingleRelationshipMapping<T extends XmlSingleRe
 						joinColumn.getNameTextRange()
 					)
 				);
-			}
-			else {
+			} else {
 				messages.add(
 					DefaultJpaValidationMessages.buildMessage(
 						IMessage.HIGH_SEVERITY,
@@ -374,7 +372,7 @@ public abstract class AbstractOrmSingleRelationshipMapping<T extends XmlSingleRe
 		}
 		
 		if ( ! joinColumn.isReferencedColumnResolved()) {
-			if (getPersistentAttribute().isVirtual()) {
+			if (this.getPersistentAttribute().isVirtual()) {
 				messages.add(
 					DefaultJpaValidationMessages.buildMessage(
 						IMessage.HIGH_SEVERITY,
@@ -384,8 +382,7 @@ public abstract class AbstractOrmSingleRelationshipMapping<T extends XmlSingleRe
 						joinColumn.getReferencedColumnNameTextRange()
 					)
 				);
-			}
-			else {
+			} else {
 				messages.add(
 					DefaultJpaValidationMessages.buildMessage(
 						IMessage.HIGH_SEVERITY,
@@ -400,7 +397,7 @@ public abstract class AbstractOrmSingleRelationshipMapping<T extends XmlSingleRe
 	}
 
 
-	// ********** OrmJoinColumn.Owner implementation **********
+	// ********** join column owner adapter **********
 
 	public class JoinColumnOwner implements OrmJoinColumn.Owner {
 
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmTypeMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmTypeMapping.java
index e8632c2135..ec6b282472 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmTypeMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmTypeMapping.java
@@ -246,7 +246,7 @@ public abstract class AbstractOrmTypeMapping<T extends AbstractXmlTypeMapping> e
 		JavaResourcePersistentType persistentTypeResource = getJpaProject().getJavaResourcePersistentType(getClass_());
 		if (persistentTypeResource == null) {
 			// try to resolve by prepending the global package name
-			persistentTypeResource = getJpaProject().getJavaResourcePersistentType(getEntityMappings().getPackage() + "." + getClass_());
+			persistentTypeResource = getJpaProject().getJavaResourcePersistentType(getEntityMappings().getPackage() + '.' + getClass_());
 		}
 		return persistentTypeResource;
 	}
@@ -270,28 +270,28 @@ public abstract class AbstractOrmTypeMapping<T extends AbstractXmlTypeMapping> e
 		return getJpaFactory().buildJavaPersistentType(this, resourcePersistentType);
 	}
 
-	public void initialize(T typeMapping) {
-		this.typeMapping = typeMapping;
-		this.class_ = typeMapping.getClassName();
+	public void initialize(T mapping) {
+		this.typeMapping = mapping;
+		this.class_ = mapping.getClassName();
 		this.initializeJavaPersistentType();
-		this.specifiedMetadataComplete = this.metadataComplete(typeMapping);
+		this.specifiedMetadataComplete = this.metadataComplete(mapping);
 		this.defaultMetadataComplete = this.defaultMetadataComplete();
-		this.specifiedAccess = AccessType.fromXmlResourceModel(typeMapping.getAccess());
+		this.specifiedAccess = AccessType.fromXmlResourceModel(mapping.getAccess());
 		this.defaultAccess = this.defaultAccess();
 	}
 	
-	public void update(T typeMapping) {
-		this.typeMapping = typeMapping;
-		this.setClass(typeMapping.getClassName());
+	public void update(T mapping) {
+		this.typeMapping = mapping;
+		this.setClass(mapping.getClassName());
 		this.updateJavaPersistentType();
-		this.setSpecifiedMetadataComplete(this.metadataComplete(typeMapping));
+		this.setSpecifiedMetadataComplete(this.metadataComplete(mapping));
 		this.setDefaultMetadataComplete(this.defaultMetadataComplete());
-		this.setSpecifiedAccess(AccessType.fromXmlResourceModel(typeMapping.getAccess()));
+		this.setSpecifiedAccess(AccessType.fromXmlResourceModel(mapping.getAccess()));
 		this.setDefaultAccess(this.defaultAccess());
 	}
 	
-	protected Boolean metadataComplete(AbstractXmlTypeMapping typeMapping) {
-		return typeMapping.getMetadataComplete();
+	protected Boolean metadataComplete(AbstractXmlTypeMapping mapping) {
+		return mapping.getMetadataComplete();
 	}
 
 
@@ -326,37 +326,33 @@ public abstract class AbstractOrmTypeMapping<T extends AbstractXmlTypeMapping> e
 	
 	//************************* validation ************************
 	@Override
-	public void addToMessages(List<IMessage> messages) {
-		super.addToMessages(messages);
-		addClassMessages(messages);
+	public void validate(List<IMessage> messages) {
+		super.validate(messages);
+		this.validateClass(messages);
 	}
-	protected void addClassMessages(List<IMessage> messages) {
-		addUnspecifiedClassMessage(messages);
-		addUnresolvedClassMessage(messages);
-	}
-	
-	protected void addUnspecifiedClassMessage(List<IMessage> messages) {
-		if (StringTools.stringIsEmpty(getClass_())) {
+
+	protected void validateClass(List<IMessage> messages) {
+		if (StringTools.stringIsEmpty(this.class_)) {
 			messages.add(
 				DefaultJpaValidationMessages.buildMessage(
 					IMessage.HIGH_SEVERITY,
 					JpaValidationMessages.PERSISTENT_TYPE_UNSPECIFIED_CLASS,
 					this, 
-					this.getClassTextRange())
+					this.getClassTextRange()
+				)
 			);
+			return;
 		}
-	}
-	
-	protected void addUnresolvedClassMessage(List<IMessage> messages) {
-		if (! StringTools.stringIsEmpty(getClass_())
-				&& getJavaPersistentType() == null) {
+
+		if (this.javaPersistentType == null) {
 			messages.add(
 				DefaultJpaValidationMessages.buildMessage(
 					IMessage.HIGH_SEVERITY,
 					JpaValidationMessages.PERSISTENT_TYPE_UNRESOLVED_CLASS,
-					new String[] {getClass_()},
+					new String[] {this.class_},
 					this, 
-					this.getClassTextRange())
+					this.getClassTextRange()
+				)
 			);
 		}
 	}
@@ -364,4 +360,10 @@ public abstract class AbstractOrmTypeMapping<T extends AbstractXmlTypeMapping> e
 	public TextRange getValidationTextRange() {
 		return this.typeMapping.getValidationTextRange();
 	}
+
+	@Override
+	public void toString(StringBuilder sb) {
+		sb.append(this.getPersistentType().getName());
+	}
+
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericEntityMappings.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericEntityMappings.java
index eb81c40b52..0cfe2753a2 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericEntityMappings.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericEntityMappings.java
@@ -37,8 +37,7 @@ import org.eclipse.jpt.core.context.orm.OrmTypeMapping;
 import org.eclipse.jpt.core.context.orm.OrmXml;
 import org.eclipse.jpt.core.context.orm.PersistenceUnitDefaults;
 import org.eclipse.jpt.core.context.orm.PersistenceUnitMetadata;
-import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages;
-import org.eclipse.jpt.core.internal.validation.JpaValidationMessages;
+import org.eclipse.jpt.core.context.persistence.PersistenceUnit;
 import org.eclipse.jpt.core.resource.orm.AbstractXmlTypeMapping;
 import org.eclipse.jpt.core.resource.orm.OrmFactory;
 import org.eclipse.jpt.core.resource.orm.XmlEmbeddable;
@@ -58,10 +57,12 @@ import org.eclipse.jpt.utility.internal.iterators.CloneListIterator;
 import org.eclipse.jpt.utility.internal.iterators.CompositeIterator;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
-
+/**
+ * 
+ */
 public class GenericEntityMappings
 	extends AbstractOrmJpaContextNode
-	implements EntityMappings
+	implements EntityMappings, PersistenceUnit.OrmGeneratorHolder, PersistenceUnit.OrmQueryHolder
 {
 	protected XmlEntityMappings xmlEntityMappings;
 	
@@ -805,9 +806,9 @@ public class GenericEntityMappings
 		}
 	}
 
-	
-	// *************************************************************************
-	
+
+	// ********** validation **********
+
 	public JpaStructureNode getStructureNode(int textOffset) {
 		for (OrmPersistentType persistentType: CollectionTools.iterable(ormPersistentTypes())) {
 			if (persistentType.contains(textOffset)) {
@@ -833,71 +834,64 @@ public class GenericEntityMappings
 	}
 	
 	@Override
-	public void addToMessages(List<IMessage> messages) {
-		super.addToMessages(messages);
+	public void validate(List<IMessage> messages) {
+		super.validate(messages);
+		this.validateGenerators(messages);
+		this.validateQueries(messages);
+		for (Iterator<OrmPersistentType> stream = this.ormPersistentTypes(); stream.hasNext(); ) {
+			this.validatePersistentType(stream.next(), messages);
+		}
+	}
+
+	protected void validateGenerators(List<IMessage> messages) {
 		try {
-			addGeneratorMessages(messages);
-			addQueryMessages(messages);
+			this.getPersistenceUnit().validateGenerators(this, messages);
 		} catch (Throwable exception) {
-			JptCorePlugin.log(exception);
-		}
-		for (OrmPersistentType ormPersistentType : CollectionTools.iterable(this.ormPersistentTypes())) {
-			try {
-				ormPersistentType.addToMessages(messages);
-			} catch (Throwable exception) {
-				JptCorePlugin.log(exception);			
-			}
+			JptCorePlugin.log(exception);  // unlikely...
 		}
 	}
-	
+
+	/**
+	 * Return all the generators, table and sequence.
+	 */
 	@SuppressWarnings("unchecked")
-	protected void addGeneratorMessages(List<IMessage> messages) {
-		List<Generator> masterList = CollectionTools.list(getPersistenceUnit().allGenerators());
-		
-		for (Iterator<OrmGenerator> stream = new CompositeIterator<OrmGenerator>(this.tableGenerators(), this.sequenceGenerators()); stream.hasNext() ; ) {
-			OrmGenerator current = stream.next();
-			masterList.remove(current);
-			
-			for (Generator each : masterList) {
-				if (! each.overrides(current) && each.getName() != null && each.getName().equals(current.getName())) {
-					messages.add(
-						DefaultJpaValidationMessages.buildMessage(
-							IMessage.HIGH_SEVERITY,
-							JpaValidationMessages.GENERATOR_DUPLICATE_NAME,
-							new String[] {current.getName()},
-							current,
-							current.getNameTextRange())
-					);
-				}
-			}
-			masterList.add(current);
+	public Iterator<OrmGenerator> generators() {
+		return new CompositeIterator<OrmGenerator>(
+						this.tableGenerators(),
+						this.sequenceGenerators()
+				);
+	}
+
+	protected void validateQueries(List<IMessage> messages) {
+		try {
+			this.getPersistenceUnit().validateQueries(this, messages);
+		} catch (Throwable exception) {
+			JptCorePlugin.log(exception);  // unlikely...
 		}
 	}
-	
+
+	/**
+	 * Return all the queries, named and named native.
+	 */
 	@SuppressWarnings("unchecked")
-	protected void addQueryMessages(List<IMessage> messages) {
-		List<Query> masterList = CollectionTools.list(getPersistenceUnit().allQueries());
-		
-		for (Iterator<OrmQuery> stream = new CompositeIterator<OrmQuery>(this.namedQueries(), this.namedNativeQueries()); stream.hasNext() ; ) {
-			OrmQuery current = stream.next();
-			masterList.remove(current);
-			
-			for (Query each : masterList) {
-				if (! each.overrides(current) && each.getName() != null && each.getName().equals(current.getName())) {
-					messages.add(
-						DefaultJpaValidationMessages.buildMessage(
-							IMessage.HIGH_SEVERITY,
-							JpaValidationMessages.QUERY_DUPLICATE_NAME,
-							new String[] {current.getName()},
-							current,
-							current.getNameTextRange())
-					);
-				}
-			}
-			masterList.add(current);
+	public Iterator<OrmQuery> queries() {
+		return new CompositeIterator<OrmQuery>(
+						this.namedQueries(),
+						this.namedNativeQueries()
+				);
+	}
+
+	protected void validatePersistentType(OrmPersistentType persistentType, List<IMessage> messages) {
+		try {
+			persistentType.validate(messages);
+		} catch (Throwable exception) {
+			JptCorePlugin.log(exception);			
 		}
 	}
-	
+
+
+	// ********** dispose **********
+
 	public void dispose() {
 		for (OrmPersistentType  ormPersistentType : CollectionTools.iterable(ormPersistentTypes())) {
 			ormPersistentType.dispose();
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmAttributeOverride.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmAttributeOverride.java
index a3d3ed12a8..fb14e2094a 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmAttributeOverride.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmAttributeOverride.java
@@ -154,58 +154,61 @@ public class GenericOrmAttributeOverride extends AbstractOrmJpaContextNode
 	//****************** validation ********************
 	
 	@Override
-	public void addToMessages(List<IMessage> messages) {
-		super.addToMessages(messages);
+	public void validate(List<IMessage> messages) {
+		super.validate(messages);
 		if (this.connectionProfileIsActive()) {
-			this.addColumnMessages(messages);
+			this.validateColumn(messages);
 		}
 	}
 	
-	protected void addColumnMessages(List<IMessage> messages) {
-		if (this.getTypeMapping().tableNameIsInvalid(this.column.getTable())) {
-			if (isVirtual()) {
+	protected void validateColumn(List<IMessage> messages) {
+		String tableName = this.column.getTable();
+		if (this.getTypeMapping().tableNameIsInvalid(tableName)) {
+			if (this.isVirtual()) {
 				messages.add(
 					DefaultJpaValidationMessages.buildMessage(
 						IMessage.HIGH_SEVERITY,
 						JpaValidationMessages.VIRTUAL_ATTRIBUTE_OVERRIDE_COLUMN_UNRESOLVED_TABLE,
-						new String[] {getName(), this.column.getTable(), this.column.getName()},
+						new String[] {this.getName(), tableName, this.column.getName()},
 						this.column, 
-						this.column.getTableTextRange())
+						this.column.getTableTextRange()
+					)
 				);
-			}
-			else {
+			} else {
 				messages.add(
-						DefaultJpaValidationMessages.buildMessage(
-							IMessage.HIGH_SEVERITY,
-							JpaValidationMessages.COLUMN_UNRESOLVED_TABLE,
-							new String[] {this.column.getTable(), this.column.getName()}, 
-							this.column,
-							this.column.getTableTextRange())
-					);
+					DefaultJpaValidationMessages.buildMessage(
+						IMessage.HIGH_SEVERITY,
+						JpaValidationMessages.COLUMN_UNRESOLVED_TABLE,
+						new String[] {tableName, this.column.getName()}, 
+						this.column,
+						this.column.getTableTextRange()
+					)
+				);
 			}
 			return;
 		}
 		
 		if ( ! this.column.isResolved()) {
-			if (isVirtual()) {
+			if (this.isVirtual()) {
 				messages.add(
 					DefaultJpaValidationMessages.buildMessage(
 						IMessage.HIGH_SEVERITY,
 						JpaValidationMessages.VIRTUAL_ATTRIBUTE_OVERRIDE_COLUMN_UNRESOLVED_NAME,
-						new String[] {getName(), this.column.getName()}, 
+						new String[] {this.getName(), this.column.getName()}, 
 						this.column,
-						this.column.getNameTextRange())
+						this.column.getNameTextRange()
+					)
 				);
-			}
-			else {
+			} else {
 				messages.add(
 					DefaultJpaValidationMessages.buildMessage(
-							IMessage.HIGH_SEVERITY,
-							JpaValidationMessages.COLUMN_UNRESOLVED_NAME,
-							new String[] {this.column.getName()}, 
-							this.column,
-							this.column.getNameTextRange())
-					);
+						IMessage.HIGH_SEVERITY,
+						JpaValidationMessages.COLUMN_UNRESOLVED_NAME,
+						new String[] {this.column.getName()}, 
+						this.column,
+						this.column.getNameTextRange()
+					)
+				);
 			}
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmBasicMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmBasicMapping.java
index 40c68c9d35..3c74eee5e7 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmBasicMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmBasicMapping.java
@@ -272,57 +272,60 @@ public class GenericOrmBasicMapping extends AbstractOrmAttributeMapping<XmlBasic
 	// ****************** validation ****************
 	
 	@Override
-	public void addToMessages(List<IMessage> messages) {
-		super.addToMessages(messages);
-		if (this.connectionProfileIsActive() && this.entityOwned()) {
-			this.addColumnMessages(messages);
+	public void validate(List<IMessage> messages) {
+		super.validate(messages);
+		if (this.connectionProfileIsActive() && this.ownerIsEntity()) {
+			this.validateColumn(messages);
 		}
 	}
 	
-	protected void addColumnMessages(List<IMessage> messages) {
-		if (this.getTypeMapping().tableNameIsInvalid(this.column.getTable())) {
-			if (getPersistentAttribute().isVirtual()) {
+	protected void validateColumn(List<IMessage> messages) {
+		String tableName = this.column.getTable();
+		if (this.getTypeMapping().tableNameIsInvalid(tableName)) {
+			if (this.getPersistentAttribute().isVirtual()) {
 				messages.add(
 					DefaultJpaValidationMessages.buildMessage(
 						IMessage.HIGH_SEVERITY,
 						JpaValidationMessages.VIRTUAL_ATTRIBUTE_COLUMN_UNRESOLVED_TABLE,
-						new String[] {getName(), this.column.getTable(), this.column.getName()},
+						new String[] {this.getName(), tableName, this.column.getName()},
 						this.column, 
-						this.column.getTableTextRange())
+						this.column.getTableTextRange()
+					)
 				);
-			}
-			else {
+			} else {
 				messages.add(
 					DefaultJpaValidationMessages.buildMessage(
 						IMessage.HIGH_SEVERITY,
 						JpaValidationMessages.COLUMN_UNRESOLVED_TABLE,
-						new String[] {this.column.getTable(), this.column.getName()}, 
+						new String[] {tableName, this.column.getName()}, 
 						this.column, 
-						this.column.getTableTextRange())
+						this.column.getTableTextRange()
+					)
 				);
 			}
 			return;
 		}
 		
 		if ( ! this.column.isResolved()) {
-			if (getPersistentAttribute().isVirtual()) {
+			if (this.getPersistentAttribute().isVirtual()) {
 				messages.add(
 					DefaultJpaValidationMessages.buildMessage(
 						IMessage.HIGH_SEVERITY,
 						JpaValidationMessages.VIRTUAL_ATTRIBUTE_COLUMN_UNRESOLVED_NAME,
-						new String[] {getName(), this.column.getName()}, 
+						new String[] {this.getName(), this.column.getName()}, 
 						this.column, 
-						this.column.getNameTextRange())
+						this.column.getNameTextRange()
+					)
 				);
-			}
-			else {
+			} else {
 				messages.add(
 					DefaultJpaValidationMessages.buildMessage(
 						IMessage.HIGH_SEVERITY,
 						JpaValidationMessages.COLUMN_UNRESOLVED_NAME,
 						new String[] {this.column.getName()}, 
 						this.column, 
-						this.column.getNameTextRange())
+						this.column.getNameTextRange()
+					)
 				);
 			}
 		}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmEntity.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmEntity.java
index 92c70fc33b..59e0bc9e47 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmEntity.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmEntity.java
@@ -22,7 +22,6 @@ import org.eclipse.jpt.core.context.BaseOverride;
 import org.eclipse.jpt.core.context.ColumnMapping;
 import org.eclipse.jpt.core.context.DiscriminatorColumn;
 import org.eclipse.jpt.core.context.Entity;
-import org.eclipse.jpt.core.context.Generator;
 import org.eclipse.jpt.core.context.IdClass;
 import org.eclipse.jpt.core.context.InheritanceType;
 import org.eclipse.jpt.core.context.NamedNativeQuery;
@@ -57,6 +56,7 @@ import org.eclipse.jpt.core.context.orm.OrmSecondaryTable;
 import org.eclipse.jpt.core.context.orm.OrmSequenceGenerator;
 import org.eclipse.jpt.core.context.orm.OrmTable;
 import org.eclipse.jpt.core.context.orm.OrmTableGenerator;
+import org.eclipse.jpt.core.context.persistence.PersistenceUnit;
 import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages;
 import org.eclipse.jpt.core.internal.validation.JpaValidationMessages;
 import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType;
@@ -81,14 +81,14 @@ import org.eclipse.jpt.utility.internal.CollectionTools;
 import org.eclipse.jpt.utility.internal.iterators.CloneListIterator;
 import org.eclipse.jpt.utility.internal.iterators.CompositeIterator;
 import org.eclipse.jpt.utility.internal.iterators.CompositeListIterator;
-import org.eclipse.jpt.utility.internal.iterators.EmptyIterator;
 import org.eclipse.jpt.utility.internal.iterators.EmptyListIterator;
 import org.eclipse.jpt.utility.internal.iterators.FilteringIterator;
-import org.eclipse.jpt.utility.internal.iterators.SingleElementIterator;
 import org.eclipse.jpt.utility.internal.iterators.TransformationIterator;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
-public class GenericOrmEntity extends AbstractOrmTypeMapping<XmlEntity> implements OrmEntity
+public class GenericOrmEntity
+	extends AbstractOrmTypeMapping<XmlEntity>
+	implements OrmEntity, PersistenceUnit.OrmGeneratorHolder, PersistenceUnit.OrmQueryHolder
 {
 	protected String specifiedName;
 
@@ -185,12 +185,12 @@ public class GenericOrmEntity extends AbstractOrmTypeMapping<XmlEntity> implemen
 
 	@Override
 	public String getPrimaryTableName() {
-		return getTable().getName();
+		return this.table.getName();
 	}
 	
 	@Override
 	public org.eclipse.jpt.db.Table getPrimaryDbTable() {
-		return getTable().getDbTable();
+		return this.table.getDbTable();
 	}
 
 	private static final org.eclipse.jpt.db.Table[] EMPTY_DB_TABLE_ARRAY = new org.eclipse.jpt.db.Table[0];
@@ -224,7 +224,7 @@ public class GenericOrmEntity extends AbstractOrmTypeMapping<XmlEntity> implemen
 	
 	@Override
 	public Schema getDbSchema() {
-		return getTable().getDbSchema();
+		return this.table.getDbSchema();
 	}
 	
 	public JavaEntity getJavaEntity() {
@@ -458,7 +458,7 @@ public class GenericOrmEntity extends AbstractOrmTypeMapping<XmlEntity> implemen
 	}
 
 	public Iterator<Table> associatedTables() {
-		return new CompositeIterator<Table>(this.getTable(), this.secondaryTables());
+		return new CompositeIterator<Table>(this.table, this.secondaryTables());
 	}
 
 	public Iterator<Table> associatedTablesIncludingInherited() {
@@ -602,11 +602,19 @@ public class GenericOrmEntity extends AbstractOrmTypeMapping<XmlEntity> implemen
 		firePropertyChanged(TABLE_GENERATOR_PROPERTY, oldTableGenerator, newTableGenerator);
 	}
 	
-	@SuppressWarnings("unchecked")
-	protected Iterator<OrmGenerator> generators() {
-		return new CompositeIterator<OrmGenerator>(
-			(getSequenceGenerator() == null) ? EmptyIterator.instance() : new SingleElementIterator(getSequenceGenerator()),
-			(getTableGenerator() == null) ? EmptyIterator.instance() : new SingleElementIterator(getTableGenerator()));
+	public Iterator<OrmGenerator> generators() {
+		ArrayList<OrmGenerator> generators = new ArrayList<OrmGenerator>();
+		this.addGeneratorsTo(generators);
+		return generators.iterator();
+	}
+
+	protected void addGeneratorsTo(ArrayList<OrmGenerator> generators) {
+		if (this.sequenceGenerator != null) {
+			generators.add(this.sequenceGenerator);
+		}
+		if (this.tableGenerator != null) {
+			generators.add(this.tableGenerator);
+		}
 	}
 
 	public String getDefaultDiscriminatorValue() {
@@ -1032,7 +1040,7 @@ public class GenericOrmEntity extends AbstractOrmTypeMapping<XmlEntity> implemen
 	}
 	
 	@SuppressWarnings("unchecked")
-	protected Iterator<OrmQuery> queries() {
+	public Iterator<OrmQuery> queries() {
 		return new CompositeIterator<OrmQuery>(this.namedQueries(), this.namedNativeQueries());
 	}
 
@@ -1873,38 +1881,37 @@ public class GenericOrmEntity extends AbstractOrmTypeMapping<XmlEntity> implemen
 	//**********  Validation **************************
 	
 	@Override
-	public void addToMessages(List<IMessage> messages) {
-		super.addToMessages(messages);
-		getTable().addToMessages(messages);	
-		addIdMessages(messages);
-		addGeneratorMessages(messages);
-		addQueryMessages(messages);
-		for (OrmSecondaryTable secondaryTable : CollectionTools.iterable(secondaryTables())) {
-			secondaryTable.addToMessages(messages);
+	public void validate(List<IMessage> messages) {
+		super.validate(messages);
+
+		this.table.validate(messages);	
+		this.validateId(messages);
+		this.getPersistenceUnit().validateGenerators(this, messages);
+		this.getPersistenceUnit().validateQueries(this, messages);
+
+		for (Iterator<OrmSecondaryTable> stream = this.secondaryTables(); stream.hasNext(); ) {
+			stream.next().validate(messages);
 		}
 
-		for (OrmAttributeOverride attributeOverride : CollectionTools.iterable(attributeOverrides())) {
-			attributeOverride.addToMessages(messages);
+		for (Iterator<OrmAttributeOverride> stream = this.attributeOverrides(); stream.hasNext(); ) {
+			stream.next().validate(messages);
 		}
 
-		for (OrmAssociationOverride associationOverride : CollectionTools.iterable(associationOverrides())) {
-			associationOverride.addToMessages(messages);
+		for (Iterator<OrmAssociationOverride> stream = this.associationOverrides(); stream.hasNext(); ) {
+			stream.next().validate(messages);
 		}
 	}
 	
-	protected void addIdMessages(List<IMessage> messages) {
-		addNoIdMessage(messages);
-	}
-	
-	protected void addNoIdMessage(List<IMessage> messages) {
-		if (entityHasNoId()) {
+	protected void validateId(List<IMessage> messages) {
+		if (this.entityHasNoId()) {
 			messages.add(
 				DefaultJpaValidationMessages.buildMessage(
 					IMessage.HIGH_SEVERITY,
 					JpaValidationMessages.ENTITY_NO_ID,
 					new String[] {this.getName()},
 					this, 
-					this.getValidationTextRange())
+					this.getValidationTextRange()
+				)
 			);
 		}
 	}
@@ -1913,54 +1920,6 @@ public class GenericOrmEntity extends AbstractOrmTypeMapping<XmlEntity> implemen
 		return ! this.entityHasId();
 	}
 	
-	protected void addGeneratorMessages(List<IMessage> messages) {
-		List<Generator> masterList = CollectionTools.list(getPersistenceUnit().allGenerators());
-		
-		for (Iterator<OrmGenerator> stream = this.generators(); stream.hasNext() ; ) {
-			OrmGenerator current = stream.next();
-			masterList.remove(current);
-			
-			for (Generator each : masterList) {
-				if (! each.overrides(current) && each.getName() != null && each.getName().equals(current.getName())) {
-					messages.add(
-						DefaultJpaValidationMessages.buildMessage(
-							IMessage.HIGH_SEVERITY,
-							JpaValidationMessages.GENERATOR_DUPLICATE_NAME,
-							new String[] {current.getName()},
-							current,
-							current.getNameTextRange())
-					);
-				}
-			}
-		
-			masterList.add(current);
-		}
-	}
-	
-	protected void addQueryMessages(List<IMessage> messages) {
-		List<Query> masterList = CollectionTools.list(getPersistenceUnit().allQueries());
-		
-		for (Iterator<OrmQuery> stream = this.queries(); stream.hasNext() ; ) {
-			OrmQuery current = stream.next();
-			masterList.remove(current);
-			
-			for (Query each : masterList) {
-				if (! each.overrides(current) && each.getName() != null && each.getName().equals(current.getName())) {
-					messages.add(
-						DefaultJpaValidationMessages.buildMessage(
-							IMessage.HIGH_SEVERITY,
-							JpaValidationMessages.QUERY_DUPLICATE_NAME,
-							new String[] {current.getName()},
-							current,
-							current.getNameTextRange())
-					);
-				}
-			}
-			
-			masterList.add(current);
-		}
-	}
-
 	private boolean entityHasId() {
 		for (Iterator<PersistentAttribute> stream = this.getPersistentType().allAttributes(); stream.hasNext(); ) {
 			if (stream.next().isIdAttribute()) {
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmIdMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmIdMapping.java
index f5c33c3315..59719aabf2 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmIdMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmIdMapping.java
@@ -9,11 +9,12 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.internal.context.orm;
 
+import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
+
 import org.eclipse.jpt.core.MappingKeys;
 import org.eclipse.jpt.core.context.Converter;
-import org.eclipse.jpt.core.context.Generator;
 import org.eclipse.jpt.core.context.orm.OrmAttributeMapping;
 import org.eclipse.jpt.core.context.orm.OrmColumn;
 import org.eclipse.jpt.core.context.orm.OrmColumnMapping;
@@ -24,6 +25,7 @@ import org.eclipse.jpt.core.context.orm.OrmIdMapping;
 import org.eclipse.jpt.core.context.orm.OrmPersistentAttribute;
 import org.eclipse.jpt.core.context.orm.OrmSequenceGenerator;
 import org.eclipse.jpt.core.context.orm.OrmTableGenerator;
+import org.eclipse.jpt.core.context.persistence.PersistenceUnit;
 import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages;
 import org.eclipse.jpt.core.internal.validation.JpaValidationMessages;
 import org.eclipse.jpt.core.resource.orm.AbstractXmlTypeMapping;
@@ -34,15 +36,14 @@ import org.eclipse.jpt.core.resource.orm.XmlId;
 import org.eclipse.jpt.core.resource.orm.XmlSequenceGenerator;
 import org.eclipse.jpt.core.resource.orm.XmlTableGenerator;
 import org.eclipse.jpt.db.Table;
-import org.eclipse.jpt.utility.internal.CollectionTools;
-import org.eclipse.jpt.utility.internal.iterators.CompositeIterator;
-import org.eclipse.jpt.utility.internal.iterators.EmptyIterator;
-import org.eclipse.jpt.utility.internal.iterators.SingleElementIterator;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
-
-public class GenericOrmIdMapping extends AbstractOrmAttributeMapping<XmlId>
-	implements OrmIdMapping
+/**
+ * 
+ */
+public class GenericOrmIdMapping
+	extends AbstractOrmAttributeMapping<XmlId>
+	implements OrmIdMapping, PersistenceUnit.OrmGeneratorHolder, PersistenceUnit.OrmGeneratedValueHolder
 {
 	protected final OrmColumn column;
 
@@ -128,7 +129,7 @@ public class GenericOrmIdMapping extends AbstractOrmAttributeMapping<XmlId>
 
 	public OrmGeneratedValue addGeneratedValue() {
 		if (getGeneratedValue() != null) {
-			throw new IllegalStateException("gemeratedValue already exists");
+			throw new IllegalStateException("gemeratedValue already exists"); //$NON-NLS-1$
 		}
 		XmlGeneratedValue resourceGeneratedValue = OrmFactory.eINSTANCE.createXmlGeneratedValueImpl();
 		this.generatedValue = buildGeneratedValue(resourceGeneratedValue);
@@ -139,7 +140,7 @@ public class GenericOrmIdMapping extends AbstractOrmAttributeMapping<XmlId>
 	
 	public void removeGeneratedValue() {
 		if (getGeneratedValue() == null) {
-			throw new IllegalStateException("gemeratedValue does not exist, cannot be removed");
+			throw new IllegalStateException("gemeratedValue does not exist, cannot be removed"); //$NON-NLS-1$
 		}
 		OrmGeneratedValue oldGeneratedValue = this.generatedValue;
 		this.generatedValue = null;
@@ -159,7 +160,7 @@ public class GenericOrmIdMapping extends AbstractOrmAttributeMapping<XmlId>
 
 	public OrmSequenceGenerator addSequenceGenerator() {
 		if (getSequenceGenerator() != null) {
-			throw new IllegalStateException("sequenceGenerator already exists");
+			throw new IllegalStateException("sequenceGenerator already exists"); //$NON-NLS-1$
 		}
 		XmlSequenceGenerator resourceSequenceGenerator = OrmFactory.eINSTANCE.createXmlSequenceGeneratorImpl();
 		this.sequenceGenerator = buildSequenceGenerator(resourceSequenceGenerator);
@@ -170,7 +171,7 @@ public class GenericOrmIdMapping extends AbstractOrmAttributeMapping<XmlId>
 	
 	public void removeSequenceGenerator() {
 		if (getSequenceGenerator() == null) {
-			throw new IllegalStateException("sequenceGenerator does not exist, cannot be removed");
+			throw new IllegalStateException("sequenceGenerator does not exist, cannot be removed"); //$NON-NLS-1$
 		}
 		OrmSequenceGenerator oldSequenceGenerator = this.sequenceGenerator;
 		this.sequenceGenerator = null;
@@ -190,7 +191,7 @@ public class GenericOrmIdMapping extends AbstractOrmAttributeMapping<XmlId>
 
 	public OrmTableGenerator addTableGenerator() {
 		if (getTableGenerator() != null) {
-			throw new IllegalStateException("tableGenerator already exists");
+			throw new IllegalStateException("tableGenerator already exists"); //$NON-NLS-1$
 		}
 		XmlTableGenerator resourceTableGenerator = OrmFactory.eINSTANCE.createXmlTableGeneratorImpl();
 		this.tableGenerator = buildTableGenerator(resourceTableGenerator);
@@ -201,7 +202,7 @@ public class GenericOrmIdMapping extends AbstractOrmAttributeMapping<XmlId>
 	
 	public void removeTableGenerator() {
 		if (getTableGenerator() == null) {
-			throw new IllegalStateException("tableGenerator does not exist, cannot be removed");
+			throw new IllegalStateException("tableGenerator does not exist, cannot be removed"); //$NON-NLS-1$
 		}
 		OrmTableGenerator oldTableGenerator = this.tableGenerator;
 		this.tableGenerator = null;
@@ -219,11 +220,19 @@ public class GenericOrmIdMapping extends AbstractOrmAttributeMapping<XmlId>
 		firePropertyChanged(TABLE_GENERATOR_PROPERTY, oldTableGenerator, newTableGenerator);
 	}
 	
-	@SuppressWarnings("unchecked")
-	protected Iterator<OrmGenerator> generators() {
-		return new CompositeIterator<OrmGenerator>(
-			(getSequenceGenerator() == null) ? EmptyIterator.instance() : new SingleElementIterator(getSequenceGenerator()),
-			(getTableGenerator() == null) ? EmptyIterator.instance() : new SingleElementIterator(getTableGenerator()));
+	public Iterator<OrmGenerator> generators() {
+		ArrayList<OrmGenerator> generators = new ArrayList<OrmGenerator>();
+		this.addGeneratorsTo(generators);
+		return generators.iterator();
+	}
+
+	protected void addGeneratorsTo(ArrayList<OrmGenerator> generators) {
+		if (this.sequenceGenerator != null) {
+			generators.add(this.sequenceGenerator);
+		}
+		if (this.tableGenerator != null) {
+			generators.add(this.tableGenerator);
+		}
 	}
 
 	@Override
@@ -414,114 +423,67 @@ public class GenericOrmIdMapping extends AbstractOrmAttributeMapping<XmlId>
 	// ****************** validation ****************
 
 	@Override
-	public void addToMessages(List<IMessage> messages) {
-		super.addToMessages(messages);
+	public void validate(List<IMessage> messages) {
+		super.validate(messages);
 		
-		if (this.connectionProfileIsActive() && this.entityOwned()) {
-			this.addColumnMessages(messages);
+		if (this.connectionProfileIsActive() && this.ownerIsEntity()) {
+			this.validateColumn(messages);
 		}
-		this.addGeneratedValueMessages(messages);
-		this.addGeneratorMessages(messages);
+		this.getPersistenceUnit().validateGeneratedValue(this, messages);
+		this.getPersistenceUnit().validateGenerators(this, messages);
 	}
 	
-	protected void addColumnMessages(List<IMessage> messages) {
-		if (this.getTypeMapping().tableNameIsInvalid(this.column.getTable())) {
-			if (getPersistentAttribute().isVirtual()) {
+	protected void validateColumn(List<IMessage> messages) {
+		OrmPersistentAttribute pa = this.getPersistentAttribute();
+		String tableName = this.column.getTable();
+		if (this.getTypeMapping().tableNameIsInvalid(tableName)) {
+			if (pa.isVirtual()) {
 				messages.add(
 					DefaultJpaValidationMessages.buildMessage(
 						IMessage.HIGH_SEVERITY,
 						JpaValidationMessages.VIRTUAL_ATTRIBUTE_COLUMN_UNRESOLVED_TABLE,
-						new String[] {getPersistentAttribute().getName(), this.column.getTable(), this.column.getName()},
+						new String[] {pa.getName(), tableName, this.column.getName()},
 						this.column, 
-						this.column.getTableTextRange())
+						this.column.getTableTextRange()
+					)
 				);
-			}
-			else {
+			} else {
 				messages.add(
 					DefaultJpaValidationMessages.buildMessage(
 						IMessage.HIGH_SEVERITY,
 						JpaValidationMessages.COLUMN_UNRESOLVED_TABLE,
-						new String[] {this.column.getTable(), this.column.getName()}, 
+						new String[] {tableName, this.column.getName()}, 
 						this.column, 
-						this.column.getTableTextRange())
+						this.column.getTableTextRange()
+					)
 				);
 			}
 			return;
 		}
 		
 		if ( ! this.column.isResolved()) {
-			if (getPersistentAttribute().isVirtual()) {
+			if (pa.isVirtual()) {
 				messages.add(
 					DefaultJpaValidationMessages.buildMessage(
 						IMessage.HIGH_SEVERITY,
 						JpaValidationMessages.VIRTUAL_ATTRIBUTE_COLUMN_UNRESOLVED_NAME,
-						new String[] {getPersistentAttribute().getName(), this.column.getName()}, 
+						new String[] {pa.getName(), this.column.getName()}, 
 						this.column, 
-						this.column.getNameTextRange())
+						this.column.getNameTextRange()
+					)
 				);
-			}
-			else {
+			} else {
 				messages.add(
 					DefaultJpaValidationMessages.buildMessage(
 						IMessage.HIGH_SEVERITY,
 						JpaValidationMessages.COLUMN_UNRESOLVED_NAME,
 						new String[] {this.column.getName()}, 
 						this.column, 
-						this.column.getNameTextRange())
+						this.column.getNameTextRange()
+					)
 				);
 			}
 		}
 	}
 	
-	protected void addGeneratedValueMessages(List<IMessage> messages) {
-		if (this.generatedValue == null) {
-			return;
-		}
-		String generatorName = this.generatedValue.getGenerator();
-		if (generatorName == null) {
-			return;
-		}
-		
-		for (Generator nextMasterGenerator : CollectionTools.iterable(getPersistenceUnit().allGenerators())) {
-			if (generatorName.equals(nextMasterGenerator.getName())) {
-				return;
-			}
-		}
-		
-		messages.add(
-			DefaultJpaValidationMessages.buildMessage(
-				IMessage.HIGH_SEVERITY,
-				JpaValidationMessages.ID_MAPPING_UNRESOLVED_GENERATOR_NAME,
-				new String[] {generatorName},
-				this,
-				this.generatedValue.getGeneratorTextRange())
-			);
-	}
-	
-	protected void addGeneratorMessages(List<IMessage> messages) {
-		List<Generator> masterList = CollectionTools.list(getPersistenceUnit().allGenerators());
-		
-		for (Iterator<OrmGenerator> stream = this.generators(); stream.hasNext() ; ) {
-			OrmGenerator current = stream.next();
-			if (current.isVirtual()) {
-				return;
-			}
-			masterList.remove(current);
-			
-			for (Generator each : masterList) {
-				if (! each.overrides(current) && each.getName() != null && each.getName().equals(current.getName())) {
-					messages.add(
-						DefaultJpaValidationMessages.buildMessage(
-							IMessage.HIGH_SEVERITY,
-							JpaValidationMessages.GENERATOR_DUPLICATE_NAME,
-							new String[] {current.getName()},
-							current,
-							current.getNameTextRange())
-					);
-				}
-			}
-			
-			masterList.add(current);
-		}
-	}
-}
\ No newline at end of file
+}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmJoinColumn.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmJoinColumn.java
index abfd559e85..311c64f0ef 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmJoinColumn.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmJoinColumn.java
@@ -129,43 +129,29 @@ public class GenericOrmJoinColumn extends AbstractOrmBaseColumn<XmlJoinColumn> i
 	protected void initialize(XmlJoinColumn xjc) {
 		this.resourceJoinColumn = xjc;
 		super.initialize(xjc);
-		this.specifiedReferencedColumnName = specifiedReferencedColumnName(xjc);
-		this.defaultReferencedColumnName = defaultReferencedColumnName();
+		this.specifiedReferencedColumnName = buildSpecifiedReferencedColumnName(xjc);
+		this.defaultReferencedColumnName = buildDefaultReferencedColumnName();
 	}
 	
 	@Override
 	public void update(XmlJoinColumn xjc) {
 		this.resourceJoinColumn = xjc;
 		super.update(xjc);
-		this.setSpecifiedReferencedColumnName_(specifiedReferencedColumnName(xjc));
-		this.setDefaultReferencedColumnName(defaultReferencedColumnName());
+		this.setSpecifiedReferencedColumnName_(buildSpecifiedReferencedColumnName(xjc));
+		this.setDefaultReferencedColumnName(buildDefaultReferencedColumnName());
 	}
 
-	protected String specifiedReferencedColumnName(XmlJoinColumn xjc) {
-		return xjc == null ? null : xjc.getReferencedColumnName();
+	protected String buildSpecifiedReferencedColumnName(XmlJoinColumn xjc) {
+		return (xjc == null) ? null : xjc.getReferencedColumnName();
 	}
 
 	@Override
 	protected String buildDefaultName() {
-		RelationshipMapping relationshipMapping = getOwner().getRelationshipMapping();
-		if (relationshipMapping == null) {
-			return null;
-		}
-		if (!getOwner().getRelationshipMapping().isRelationshipOwner()) {
-			return null;
-		}
 		return MappingTools.buildJoinColumnDefaultName(this);
 	}
 	
-	protected String defaultReferencedColumnName() {
-		RelationshipMapping relationshipMapping = getOwner().getRelationshipMapping();
-		if (relationshipMapping == null) {
-			return null;
-		}
-		if (!relationshipMapping.isRelationshipOwner()) {
-			return null;
-		}
-		return MappingTools.buildJoinColumnDefaultReferencedColumnName(this);
+	protected String buildDefaultReferencedColumnName() {
+		return MappingTools.buildJoinColumnDefaultReferencedColumnName(this.getOwner());
 	}
 	
 	@Override
@@ -184,30 +170,34 @@ public class GenericOrmJoinColumn extends AbstractOrmBaseColumn<XmlJoinColumn> i
 	//******************* validation ***********************
 
 	@Override
-	public void addToMessages(List<IMessage> messages) {
-		super.addToMessages(messages);
-	
+	public void validate(List<IMessage> messages) {
+		super.validate(messages);
 		if ( ! this.isResolved()) {
-			OrmRelationshipMapping mapping = (OrmRelationshipMapping) this.getOwner().getRelationshipMapping();
-			if (mapping.getPersistentAttribute().isVirtual()) {
-				messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
+			messages.add(this.buildUnresolvedMessage());
+		}
+	}
+
+	protected IMessage buildUnresolvedMessage() {
+		OrmRelationshipMapping mapping = (OrmRelationshipMapping) this.getOwner().getRelationshipMapping();
+		return mapping.getPersistentAttribute().isVirtual() ? this.buildVirtualUnresolvedMessage(mapping) : this.buildNonVirtualUnresolvedMessage();
+	}
+
+	protected IMessage buildVirtualUnresolvedMessage(OrmRelationshipMapping mapping) {
+		return this.buildMessage(
 						JpaValidationMessages.VIRTUAL_ATTRIBUTE_COLUMN_UNRESOLVED_NAME,
-						new String[] {mapping.getName(), this.getName()}, 
-						this,
-						this.getNameTextRange())
-				);
-			} else {
-				messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
+						new String[] {mapping.getName(), this.getName()}
+					);
+	}
+
+	protected IMessage buildNonVirtualUnresolvedMessage() {
+		return this.buildMessage(
 						JpaValidationMessages.COLUMN_UNRESOLVED_NAME,
-						new String[] {this.getName()}, 
-						this,
-						this.getNameTextRange())
-				);
-			}
-		}
+						new String[] {this.getName()}
+					);
 	}
+
+	protected IMessage buildMessage(String msgID, String[] parms) {
+		return DefaultJpaValidationMessages.buildMessage(IMessage.HIGH_SEVERITY, msgID, parms, this, this.getNameTextRange());
+	}
+
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmJoinTable.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmJoinTable.java
index 17dbde1582..765edd785a 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmJoinTable.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmJoinTable.java
@@ -470,14 +470,14 @@ public class GenericOrmJoinTable
 	// ************************** validation ***********************
 
 	@Override
-	public void addToMessages(List<IMessage> messages) {
-		super.addToMessages(messages);
+	public void validate(List<IMessage> messages) {
+		super.validate(messages);
 		if (this.connectionProfileIsActive()) {
-			this.checkDatabase(messages);
+			this.validateAgainstDatabase(messages);
 		}
 	}
 
-	protected void checkDatabase(List<IMessage> messages) {
+	protected void validateAgainstDatabase(List<IMessage> messages) {
 		OrmRelationshipMapping mapping = this.getRelationshipMapping();
 
 		if ( ! this.hasResolvedCatalog()) {
@@ -488,7 +488,8 @@ public class GenericOrmJoinTable
 						JpaValidationMessages.VIRTUAL_ATTRIBUTE_JOIN_TABLE_UNRESOLVED_CATALOG,
 						new String[] {mapping.getName(), this.getCatalog(), this.getName()}, 
 						this,
-						this.getCatalogTextRange())
+						this.getCatalogTextRange()
+					)
 				);
 				
 			} else {
@@ -498,7 +499,8 @@ public class GenericOrmJoinTable
 						JpaValidationMessages.JOIN_TABLE_UNRESOLVED_CATALOG,
 						new String[] {this.getCatalog(), this.getName()}, 
 						this,
-						this.getCatalogTextRange())
+						this.getCatalogTextRange()
+					)
 				);
 			}
 			return;
@@ -512,9 +514,9 @@ public class GenericOrmJoinTable
 						JpaValidationMessages.VIRTUAL_ATTRIBUTE_JOIN_TABLE_UNRESOLVED_SCHEMA,
 						new String[] {mapping.getName(), this.getSchema(), this.getName()}, 
 						this,
-						this.getSchemaTextRange())
+						this.getSchemaTextRange()
+					)
 				);
-				
 			} else {
 				messages.add(
 					DefaultJpaValidationMessages.buildMessage(
@@ -522,7 +524,8 @@ public class GenericOrmJoinTable
 						JpaValidationMessages.JOIN_TABLE_UNRESOLVED_SCHEMA,
 						new String[] {this.getSchema(), this.getName()}, 
 						this,
-						this.getSchemaTextRange())
+						this.getSchemaTextRange()
+					)
 				);
 			}
 			return;
@@ -536,10 +539,10 @@ public class GenericOrmJoinTable
 						JpaValidationMessages.VIRTUAL_ATTRIBUTE_JOIN_TABLE_UNRESOLVED_NAME,
 						new String[] {mapping.getName(), this.getName()}, 
 						this,
-						this.getNameTextRange())
+						this.getNameTextRange()
+					)
 				);
-			}
-			else {
+			} else {
 				String attributeName = mapping.getPersistentAttribute().getName();
 				messages.add(
 					DefaultJpaValidationMessages.buildMessage(
@@ -547,19 +550,20 @@ public class GenericOrmJoinTable
 						JpaValidationMessages.JOIN_TABLE_CANNOT_BE_DETERMINED,
 						new String[] {attributeName},
 						this,
-						this.getNameTextRange())
+						this.getNameTextRange()
+					)
 				);
 			}
 			return;
 		}
 
-		this.checkJoinColumns(this.joinColumns(), messages);
-		this.checkJoinColumns(this.inverseJoinColumns(), messages);
+		this.validateJoinColumns(this.joinColumns(), messages);
+		this.validateJoinColumns(this.inverseJoinColumns(), messages);
 	}
 
-	protected void checkJoinColumns(Iterator<OrmJoinColumn> joinColumns, List<IMessage> messages) {
+	protected void validateJoinColumns(Iterator<OrmJoinColumn> joinColumns, List<IMessage> messages) {
 		while (joinColumns.hasNext()) {
-			joinColumns.next().addToMessages(messages);
+			joinColumns.next().validate(messages);
 		}
 	}
 
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmOneToOneMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmOneToOneMapping.java
index 6aa760e9f4..462ee8bd9a 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmOneToOneMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmOneToOneMapping.java
@@ -241,57 +241,55 @@ public class GenericOrmOneToOneMapping
 	// ********** Validation **********
 
 	@Override
-	public void addToMessages(List<IMessage> messages) {
-		super.addToMessages(messages);
-		
+	public void validate(List<IMessage> messages) {
+		super.validate(messages);
 		if (this.mappedBy != null) {
-			this.checkMappedBy(messages);
+			this.validateMappedBy(messages);
 		}
 	}
 	
 	@Override
-	protected void checkJoinColumns(List<IMessage> messages) {
+	protected void validateJoinColumns(List<IMessage> messages) {
 		if (this.primaryKeyJoinColumns.isEmpty() || this.containsSpecifiedJoinColumns()) {
-			super.checkJoinColumns(messages);
+			super.validateJoinColumns(messages);
 		}
 	}
 
-	protected void checkMappedBy(List<IMessage> messages) {
+	protected void validateMappedBy(List<IMessage> messages) {
 		Entity targetEntity = this.getResolvedTargetEntity();
 		if (targetEntity == null) {
-			// already have validation messages for that
-			return;
+			return;  // validated elsewhere
 		}
 		
 		PersistentAttribute attribute = targetEntity.getPersistentType().resolveAttribute(this.mappedBy);
 		
 		if (attribute == null) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.MAPPING_UNRESOLVED_MAPPED_BY,
-						new String[] {this.mappedBy}, 
-						this,
-						this.getMappedByTextRange()
-					)
-				);
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.MAPPING_UNRESOLVED_MAPPED_BY,
+					new String[] {this.mappedBy}, 
+					this,
+					this.getMappedByTextRange()
+				)
+			);
 			return;
 		}
 		
-		if ( ! this.mappedByIsValid(attribute.getMapping())) {
+		AttributeMapping mappedByMapping = attribute.getMapping();
+		if ( ! this.mappedByIsValid(mappedByMapping)) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.MAPPING_INVALID_MAPPED_BY,
-						new String[] {this.mappedBy}, 
-						this,
-						this.getMappedByTextRange()
-					)
-				);
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.MAPPING_INVALID_MAPPED_BY,
+					new String[] {this.mappedBy}, 
+					this,
+					this.getMappedByTextRange()
+				)
+			);
 			return;
 		}
 		
-		AttributeMapping mappedByMapping = attribute.getMapping();
 		if ((mappedByMapping instanceof NonOwningMapping)
 				&& ((NonOwningMapping) mappedByMapping).getMappedBy() != null) {
 			messages.add(
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmPersistentAttribute.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmPersistentAttribute.java
index 98d1a5c909..a6fb2240da 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmPersistentAttribute.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmPersistentAttribute.java
@@ -333,9 +333,9 @@ public class GenericOrmPersistentAttribute extends AbstractOrmJpaContextNode
 	}
 	
 	@Override
-	public void addToMessages(List<IMessage> messages) {
-		super.addToMessages(messages);
-		getMapping().addToMessages(messages);
+	public void validate(List<IMessage> messages) {
+		super.validate(messages);
+		this.attributeMapping.validate(messages);
 	}
 	
 	public TextRange getValidationTextRange() {
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmPersistentType.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmPersistentType.java
index a62e7d4c56..328999fc70 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmPersistentType.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmPersistentType.java
@@ -15,6 +15,7 @@ import java.util.Comparator;
 import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;
+
 import org.eclipse.jpt.core.JpaStructureNode;
 import org.eclipse.jpt.core.JptCorePlugin;
 import org.eclipse.jpt.core.MappingKeys;
@@ -71,8 +72,12 @@ import org.eclipse.jpt.utility.internal.iterators.FilteringIterator;
 import org.eclipse.jpt.utility.internal.iterators.TransformationIterator;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
-
-public class GenericOrmPersistentType extends AbstractOrmJpaContextNode implements OrmPersistentType
+/**
+ * 
+ */
+public class GenericOrmPersistentType
+	extends AbstractOrmJpaContextNode
+	implements OrmPersistentType
 {
 	protected final List<OrmPersistentAttribute> specifiedPersistentAttributes;
 
@@ -104,7 +109,7 @@ public class GenericOrmPersistentType extends AbstractOrmJpaContextNode implemen
 		if (className.equals(fullyQualifiedTypeName)) {
 			return true;
 		}
-		if ((getEntityMappings().getPackage() + "." +  className).equals(fullyQualifiedTypeName)) {
+		if ((getEntityMappings().getPackage() + '.' +  className).equals(fullyQualifiedTypeName)) {
 			return true;
 		}
 		return false;
@@ -212,7 +217,7 @@ public class GenericOrmPersistentType extends AbstractOrmJpaContextNode implemen
 
 	public void makePersistentAttributeVirtual(OrmPersistentAttribute ormPersistentAttribute) {
 		if (ormPersistentAttribute.isVirtual()) {
-			throw new IllegalStateException("Attribute is already virtual");
+			throw new IllegalStateException("Attribute is already virtual"); //$NON-NLS-1$
 		}
 		JavaPersistentAttribute javaPersistentAttribute = ormPersistentAttribute.getMapping().getJavaPersistentAttribute();
 		OrmPersistentAttribute virtualPersistentAttribute = null;
@@ -232,10 +237,10 @@ public class GenericOrmPersistentType extends AbstractOrmJpaContextNode implemen
 
 	public void makePersistentAttributeSpecified(OrmPersistentAttribute ormPersistentAttribute, String mappingKey) {
 		if (!ormPersistentAttribute.isVirtual()) {
-			throw new IllegalStateException("Attribute is already specified");
+			throw new IllegalStateException("Attribute is already specified"); //$NON-NLS-1$
 		}
 		if (mappingKey == MappingKeys.NULL_ATTRIBUTE_MAPPING_KEY) {
-			throw new IllegalStateException("Use makePersistentAttributeSpecified(OrmPersistentAttribute, String) instead and specify a mapping type");
+			throw new IllegalStateException("Use makePersistentAttributeSpecified(OrmPersistentAttribute, String) instead and specify a mapping type"); //$NON-NLS-1$
 		}
 			
 		OrmPersistentAttribute newPersistentAttribute = getJpaFactory().buildOrmPersistentAttribute(this, mappingKey);
@@ -876,21 +881,31 @@ public class GenericOrmPersistentType extends AbstractOrmJpaContextNode implemen
 	//******************** validation **********************
 	
 	@Override
-	public void addToMessages(List<IMessage> messages) {
-		super.addToMessages(messages);
-
+	public void validate(List<IMessage> messages) {
+		super.validate(messages);
+		this.validateMapping(messages);
+		this.validateAttributes(messages);
+	}
+	
+	protected void validateMapping(List<IMessage> messages) {
 		try {
-			getMapping().addToMessages(messages);
+			this.ormTypeMapping.validate(messages);
 		} catch(Throwable t) {
 			JptCorePlugin.log(t);
 		}
-		
-		for (OrmPersistentAttribute persistentAttribute : CollectionTools.iterable(this.attributes())) {
-			try {
-				persistentAttribute.addToMessages(messages);
-			} catch(Throwable t) {
-				JptCorePlugin.log(t);
-			}
+	}
+	
+	protected void validateAttributes(List<IMessage> messages) {
+		for (Iterator<OrmPersistentAttribute> stream = this.attributes(); stream.hasNext(); ) {
+			this.validateAttribute(stream.next(), messages);
+		}
+	}
+	
+	protected void validateAttribute(OrmPersistentAttribute attribute, List<IMessage> messages) {
+		try {
+			attribute.validate(messages);
+		} catch(Throwable t) {
+			JptCorePlugin.log(t);
 		}
 	}
 	
@@ -903,4 +918,10 @@ public class GenericOrmPersistentType extends AbstractOrmJpaContextNode implemen
 			getJavaPersistentType().dispose();
 		}
 	}
+
+	@Override
+	public void toString(StringBuilder sb) {
+		sb.append(this.getName());
+	}
+
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmSecondaryTable.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmSecondaryTable.java
index 5c649153a5..7e39370f9b 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmSecondaryTable.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmSecondaryTable.java
@@ -283,55 +283,64 @@ public class GenericOrmSecondaryTable
 		return this.getContextDefaultCatalog();
 	}
 
+
+	// ********** validation **********
+
 	@Override
-	public void addToMessages(List<IMessage> messages) {
-		super.addToMessages(messages);
+	public void validate(List<IMessage> messages) {
+		super.validate(messages);
 		if (this.connectionProfileIsActive()) {
-			this.checkDatabase(messages);
+			this.validateAgainstDatabase(messages);
 		}
 		for (Iterator<OrmPrimaryKeyJoinColumn> stream = this.primaryKeyJoinColumns(); stream.hasNext(); ) {
-			stream.next().addToMessages(messages);
+			stream.next().validate(messages);
 		}
 	}
 
-	protected void checkDatabase(List<IMessage> messages) {
+	protected void validateAgainstDatabase(List<IMessage> messages) {
 		if ( ! this.hasResolvedCatalog()) {
 			messages.add(
 				DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.SECONDARY_TABLE_UNRESOLVED_CATALOG,
-						new String[] {this.getCatalog(), this.getName()}, 
-						this,
-						this.getCatalogTextRange())
-				);
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.SECONDARY_TABLE_UNRESOLVED_CATALOG,
+					new String[] {this.getCatalog(), this.getName()}, 
+					this,
+					this.getCatalogTextRange()
+				)
+			);
 			return;
 		}
 		
 		if ( ! this.hasResolvedSchema()) {
 			messages.add(
 				DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.SECONDARY_TABLE_UNRESOLVED_SCHEMA,
-						new String[] {this.getSchema(), this.getName()}, 
-						this,
-						this.getSchemaTextRange())
-				);
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.SECONDARY_TABLE_UNRESOLVED_SCHEMA,
+					new String[] {this.getSchema(), this.getName()}, 
+					this,
+					this.getSchemaTextRange()
+				)
+			);
 			return;
 		}
 		
 		if ( ! this.isResolved()) {
 			messages.add(
 				DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.SECONDARY_TABLE_UNRESOLVED_NAME,
-						new String[] {this.getName()}, 
-						this, 
-						this.getNameTextRange())
-				);
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.SECONDARY_TABLE_UNRESOLVED_NAME,
+					new String[] {this.getName()}, 
+					this, 
+					this.getNameTextRange()
+				)
+			);
 			return;
 		}
 	}
 	
+
+	// ********** pk join column owner adapter **********
+
 	class PrimaryKeyJoinColumnOwner implements OrmBaseJoinColumn.Owner
 	{
 
@@ -366,5 +375,7 @@ public class GenericOrmSecondaryTable
 			// TODO Auto-generated method stub
 			return null;
 		}
+
 	}
+
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmTable.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmTable.java
index 142f733a86..5bfd2bedc3 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmTable.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmTable.java
@@ -86,47 +86,50 @@ public class GenericOrmTable
 	//*********** Validation *******************************
 	
 	@Override
-	public void addToMessages(List<IMessage> messages) {
-		super.addToMessages(messages);
+	public void validate(List<IMessage> messages) {
+		super.validate(messages);
 		if (this.connectionProfileIsActive()) {
-			this.checkDatabase(messages);
+			this.validateAgainstDatabase(messages);
 		}
 	}
 
-	protected void checkDatabase(List<IMessage> messages) {
+	protected void validateAgainstDatabase(List<IMessage> messages) {
 		if ( ! this.hasResolvedCatalog()) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.TABLE_UNRESOLVED_CATALOG,
-						new String[] {this.getCatalog(), this.getName()}, 
-						this,
-						this.getCatalogTextRange())
-				);
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.TABLE_UNRESOLVED_CATALOG,
+					new String[] {this.getCatalog(), this.getName()}, 
+					this,
+					this.getCatalogTextRange()
+				)
+			);
 			return;
 		}
 		
 		if ( ! this.hasResolvedSchema()) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.TABLE_UNRESOLVED_SCHEMA,
-						new String[] {this.getSchema(), this.getName()}, 
-						this,
-						this.getSchemaTextRange())
-				);
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.TABLE_UNRESOLVED_SCHEMA,
+					new String[] {this.getSchema(), this.getName()}, 
+					this,
+					this.getSchemaTextRange()
+				)
+			);
 			return;
 		}
 		
 		if ( ! this.isResolved()) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.TABLE_UNRESOLVED_NAME,
-						new String[] {this.getName()}, 
-						this, 
-						this.getNameTextRange())
-				);
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.TABLE_UNRESOLVED_NAME,
+					new String[] {this.getName()}, 
+					this, 
+					this.getNameTextRange()
+				)
+			);
 			return;
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmVersionMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmVersionMapping.java
index 5d518ca956..b5e55db157 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmVersionMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmVersionMapping.java
@@ -183,60 +183,65 @@ public class GenericOrmVersionMapping extends AbstractOrmAttributeMapping<XmlVer
 	// ****************** validation ****************
 	
 	@Override
-	public void addToMessages(List<IMessage> messages) {
-		super.addToMessages(messages);
+	public void validate(List<IMessage> messages) {
+		super.validate(messages);
 		
-		if (this.connectionProfileIsActive() && this.entityOwned()) {
-			this.addColumnMessages(messages);
+		if (this.connectionProfileIsActive() && this.ownerIsEntity()) {
+			this.validateColumn(messages);
 		}
 	}
 	
-	protected void addColumnMessages(List<IMessage> messages) {
-		if (this.getTypeMapping().tableNameIsInvalid(this.column.getTable())) {
-			if (getPersistentAttribute().isVirtual()) {
+	protected void validateColumn(List<IMessage> messages) {
+		OrmPersistentAttribute pa = this.getPersistentAttribute();
+		String tableName = this.column.getTable();
+		if (this.getTypeMapping().tableNameIsInvalid(tableName)) {
+			if (pa.isVirtual()) {
 				messages.add(
 					DefaultJpaValidationMessages.buildMessage(
 						IMessage.HIGH_SEVERITY,
 						JpaValidationMessages.VIRTUAL_ATTRIBUTE_COLUMN_UNRESOLVED_TABLE,
-						new String[] {getPersistentAttribute().getName(), this.column.getTable(), this.column.getName()},
+						new String[] {pa.getName(), tableName, this.column.getName()},
 						this.column,
-						this.column.getTableTextRange())
+						this.column.getTableTextRange()
+					)
 				);
-			}
-			else {
+			} else {
 				messages.add(
 					DefaultJpaValidationMessages.buildMessage(
 						IMessage.HIGH_SEVERITY,
 						JpaValidationMessages.COLUMN_UNRESOLVED_TABLE,
-						new String[] {this.column.getTable(), this.column.getName()}, 
+						new String[] {tableName, this.column.getName()}, 
 						this.column,
-						this.column.getTableTextRange())
+						this.column.getTableTextRange()
+					)
 				);
 			}
 			return;
 		}
 		
 		if ( ! this.column.isResolved()) {
-			if (getPersistentAttribute().isVirtual()) {
+			if (pa.isVirtual()) {
 				messages.add(
 					DefaultJpaValidationMessages.buildMessage(
 						IMessage.HIGH_SEVERITY,
 						JpaValidationMessages.VIRTUAL_ATTRIBUTE_COLUMN_UNRESOLVED_NAME,
-						new String[] {getPersistentAttribute().getName(), this.column.getName()}, 
+						new String[] {pa.getName(), this.column.getName()}, 
 						this.column,
-						this.column.getNameTextRange())
+						this.column.getNameTextRange()
+					)
 				);
-			}
-			else {
+			} else {
 				messages.add(
 					DefaultJpaValidationMessages.buildMessage(
 						IMessage.HIGH_SEVERITY,
 						JpaValidationMessages.COLUMN_UNRESOLVED_NAME,
-						new String[] {this.column.getName()}, 
+						new String[] {this.column.getName()},
 						this.column,
-						this.column.getNameTextRange())
+						this.column.getNameTextRange()
+					)
 				);
 			}
 		}
 	}
+
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/OrmXmlImpl.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/OrmXmlImpl.java
index 28e5218d82..56a3cf3907 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/OrmXmlImpl.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/OrmXmlImpl.java
@@ -1,13 +1,12 @@
 /*******************************************************************************
- *  Copyright (c) 2007 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
- *******************************************************************************/
+ * Copyright (c) 2007, 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.orm;
 
 import java.util.List;
@@ -24,7 +23,11 @@ import org.eclipse.jpt.core.resource.orm.XmlEntityMappings;
 import org.eclipse.jpt.core.utility.TextRange;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
-public class OrmXmlImpl extends AbstractOrmJpaContextNode
+/**
+ * 
+ */
+public class OrmXmlImpl
+	extends AbstractOrmJpaContextNode
 	implements OrmXml
 {
 	protected OrmResource ormResource;
@@ -48,10 +51,7 @@ public class OrmXmlImpl extends AbstractOrmJpaContextNode
 	}
 	
 	public OrmPersistentType getPersistentType(String fullyQualifiedTypeName) {
-		if (getEntityMappings() != null) {
-			return getEntityMappings().getPersistentType(fullyQualifiedTypeName);
-		}
-		return null;
+		return (this.entityMappings == null) ? null : this.entityMappings.getPersistentType(fullyQualifiedTypeName);
 	}
 	
 	@Override
@@ -99,37 +99,36 @@ public class OrmXmlImpl extends AbstractOrmJpaContextNode
 	}
 	
 	public PersistenceUnitDefaults getPersistenceUnitDefaults() {
-		if (getEntityMappings() != null) {
-			return getEntityMappings().getPersistenceUnitDefaults();
-		}
-		return null;
+		return (this.entityMappings == null) ? null : this.entityMappings.getPersistenceUnitDefaults();
 	}
+
+
 	// **************** updating ***********************************************
 	
-	protected void initialize(OrmResource ormResource) {
-		this.ormResource = ormResource;
-		if (ormResource.getEntityMappings() != null) {
-			this.entityMappings = buildEntityMappings(ormResource.getEntityMappings());
+	protected void initialize(OrmResource resource) {
+		this.ormResource = resource;
+		XmlEntityMappings xmlEntityMappings = resource.getEntityMappings();
+		if (xmlEntityMappings != null) {
+			this.entityMappings = buildEntityMappings(xmlEntityMappings);
 		}
 	}
 
-	public void update(OrmResource ormResource) {
-		this.ormResource = ormResource;
-		if (ormResource.getEntityMappings() != null) {
+	public void update(OrmResource resource) {
+		this.ormResource = resource;
+		XmlEntityMappings xmlEntityMappings = resource.getEntityMappings();
+		if (xmlEntityMappings != null) {
 			if (this.entityMappings != null) {
-				getJpaFile(this.ormResource.getResourceModel()).addRootStructureNode(this.ormResource, this.entityMappings);
-				this.entityMappings.update(ormResource.getEntityMappings());
+				this.getJpaFile(this.ormResource.getResourceModel()).addRootStructureNode(this.ormResource, this.entityMappings);
+				this.entityMappings.update(xmlEntityMappings);
+			} else {
+				this.setEntityMappings(this.buildEntityMappings(xmlEntityMappings));
 			}
-			else {
-				setEntityMappings(buildEntityMappings(ormResource.getEntityMappings()));
-			}
-		}
-		else {
-			if (getEntityMappings() != null) {
-				getJpaFile(this.ormResource.getResourceModel()).removeRootStructureNode(this.ormResource);
-				getEntityMappings().dispose();
+		} else {
+			if (this.entityMappings != null) {
+				this.getJpaFile(this.ormResource.getResourceModel()).removeRootStructureNode(this.ormResource);
+				this.entityMappings.dispose();
 			}
-			setEntityMappings(null);
+			this.setEntityMappings(null);
 		}
 	}
 	
@@ -158,16 +157,17 @@ public class OrmXmlImpl extends AbstractOrmJpaContextNode
 	
 	
 	@Override
-	public void addToMessages(List<IMessage> messages) {
-		super.addToMessages(messages);
-		if (getEntityMappings() != null) {
-			getEntityMappings().addToMessages(messages);
+	public void validate(List<IMessage> messages) {
+		super.validate(messages);
+		if (this.entityMappings != null) {
+			this.entityMappings.validate(messages);
 		}
 	}
 	
 	public void dispose() {
-		if (getEntityMappings() != null) {
-			getEntityMappings().dispose();
+		if (this.entityMappings != null) {
+			this.entityMappings.dispose();
 		}
 	}
+
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/AbstractPersistenceJpaContextNode.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/AbstractPersistenceJpaContextNode.java
index 0896417bdd..1c0c376663 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/AbstractPersistenceJpaContextNode.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/AbstractPersistenceJpaContextNode.java
@@ -15,22 +15,26 @@ import org.eclipse.jpt.core.context.persistence.PersistenceJpaContextNode;
 import org.eclipse.jpt.core.internal.context.AbstractJpaContextNode;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
-public abstract class AbstractPersistenceJpaContextNode extends AbstractJpaContextNode implements PersistenceJpaContextNode
+public abstract class AbstractPersistenceJpaContextNode
+	extends AbstractJpaContextNode
+	implements PersistenceJpaContextNode
 {
+
 	// ********** constructor **********
 
 	protected AbstractPersistenceJpaContextNode(JpaContextNode parent) {
 		super(parent);
 	}
 	
+
 	// ********** validation **********
 	
 	/**
 	 * All subclass implementations {@link #addToMessages(List<IMessage>)} 
 	 * should be preceded by a "super" call to this method
 	 */
-	public void addToMessages(List<IMessage> messages) {
-		
+	public void validate(List<IMessage> messages) {
+		// do nothing by default
 	}
 
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericClassRef.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericClassRef.java
index 47698fe05a..88f7f19bf9 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericClassRef.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericClassRef.java
@@ -11,6 +11,7 @@
 package org.eclipse.jpt.core.internal.context.persistence;
 
 import java.util.List;
+
 import org.eclipse.jpt.core.JpaStructureNode;
 import org.eclipse.jpt.core.JptCorePlugin;
 import org.eclipse.jpt.core.context.java.JavaPersistentType;
@@ -155,63 +156,59 @@ public class GenericClassRef extends AbstractPersistenceJpaContextNode
 	protected JavaPersistentType buildJavaPersistentType(JavaResourcePersistentType jrpt) {
 		return getJpaFactory().buildJavaPersistentType(this, jrpt);
 	}
-	
-	
-	// *************************************************************************
 
-	// ************************* validation *********************************
+
+	// ********** validation **********
 
 	@Override
-	public void addToMessages(List<IMessage> messages) {
-		super.addToMessages(messages);
-		addUnspecifiedClassMessage(messages);
-		addUnresolvedClassMessage(messages);
-		addJavaPersistentTypeMessages(messages);
-	}
-	
-	protected void addUnspecifiedClassMessage(List<IMessage> messages) {
-		if (StringTools.stringIsEmpty(getClassName())) {
+	public void validate(List<IMessage> messages) {
+		super.validate(messages);
+		if (StringTools.stringIsEmpty(this.className)) {
 			messages.add(
 				DefaultJpaValidationMessages.buildMessage(
 					IMessage.HIGH_SEVERITY,
 					JpaValidationMessages.PERSISTENCE_UNIT_UNSPECIFIED_CLASS,
-					this, getValidationTextRange())
+					this,
+					this.getValidationTextRange()
+				)
 			);
+			return;
 		}
-	}
-	
-	protected void addUnresolvedClassMessage(List<IMessage> messages) {
-		if (! StringTools.stringIsEmpty(getClassName()) && getJavaPersistentType() == null) {
+		if (this.javaPersistentType == null) {
 			messages.add(
 				DefaultJpaValidationMessages.buildMessage(
 					IMessage.HIGH_SEVERITY,
 					JpaValidationMessages.PERSISTENCE_UNIT_NONEXISTENT_CLASS,
-					new String[] {getClassName()}, 
+					new String[] {this.className}, 
 					this, 
-					this.getValidationTextRange())
+					this.getValidationTextRange()
+				)
 			);
+			return;
 		}
-	}
-	
-	protected void addJavaPersistentTypeMessages(List<IMessage> messages) {
-		if (getJavaPersistentType() != null) { //class might not resolve to a java type
-			MappingFileRef mappingFileRef = getMappingFileContaining(getClassName());
-			if (mappingFileRef != null) {
-				messages.add(DefaultJpaValidationMessages.buildMessage(
+		MappingFileRef mappingFileRef = this.getMappingFileContaining(this.className);
+		if (mappingFileRef != null) {
+			messages.add(
+				DefaultJpaValidationMessages.buildMessage(
 					IMessage.LOW_SEVERITY,
 					JpaValidationMessages.PERSISTENCE_UNIT_REDUNDANT_CLASS,
-					new String[] { this.getClassName(), mappingFileRef.getFileName()},
+					new String[] {this.className, mappingFileRef.getFileName()},
 					this,
-					this.getValidationTextRange()));
-			}
-			else {
-				try {
-					//bug 190062 - only add java validation messages if this class is not listed in a mapping file
-					getJavaPersistentType().addToMessages(messages);
-				} catch (Throwable t) {
-					JptCorePlugin.log(t);
-				}
-			}
+					this.getValidationTextRange()
+				)
+			);
+			return;
+		}
+		// 190062 only add Java validation messages if this class is not listed
+		// in a mapping file
+		this.validateJavaPersistentType(messages);
+	}
+
+	protected void validateJavaPersistentType(List<IMessage> messages) {
+		try {
+			this.javaPersistentType.validate(messages);
+		} catch (Throwable t) {
+			JptCorePlugin.log(t);
 		}
 	}
 	
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericMappingFileRef.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericMappingFileRef.java
index 5cf0ddf4b1..07e7728dfd 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericMappingFileRef.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericMappingFileRef.java
@@ -200,69 +200,64 @@ public class GenericMappingFileRef extends AbstractPersistenceJpaContextNode
 		}
 		return this.xmlMappingFileRef.getValidationTextRange();
 	}
-	
-	//**************** Validation *************************
-	
+
 	@Override
-	public void addToMessages(List<IMessage> messages) {
-		super.addToMessages(messages);
-		this.addUnspecifiedMappingFileMessage(messages);
-		this.addUnresolvedMappingFileMessage(messages);
-		this.addInvalidMappingFileContentMessage(messages);
-		if (getOrmXml() != null) {
-			getOrmXml().addToMessages(messages);
+	public void toString(StringBuilder sb) {
+		super.toString(sb);
+		sb.append(this.getFileName());
+	}
+
+	public void dispose() {
+		if (this.getOrmXml() != null) {
+			this.getOrmXml().dispose();
 		}
 	}
-	
-	
-	protected void addUnspecifiedMappingFileMessage(List<IMessage> messages) {
-		if (StringTools.stringIsEmpty(getFileName())) {
+
+
+	//**************** Validation *************************
+
+	@Override
+	public void validate(List<IMessage> messages) {
+		super.validate(messages);
+
+		if (StringTools.stringIsEmpty(this.fileName)) {
 			messages.add(
 				DefaultJpaValidationMessages.buildMessage(
 					IMessage.HIGH_SEVERITY,
 					JpaValidationMessages.PERSISTENCE_UNIT_UNSPECIFIED_MAPPING_FILE,
-					this, 
-					getValidationTextRange())
+					this,
+					this.getValidationTextRange()
+				)
 			);
+			return;
 		}
-	}
-	
-	protected void addUnresolvedMappingFileMessage(List<IMessage> messages) {
-		if (!StringTools.stringIsEmpty(getFileName()) && getOrmXml() == null) {
+
+		if (this.ormXml == null) {
 			messages.add(
 				DefaultJpaValidationMessages.buildMessage(
 					IMessage.HIGH_SEVERITY,
 					JpaValidationMessages.PERSISTENCE_UNIT_NONEXISTENT_MAPPING_FILE,
-					new String[] {getFileName()}, 
-					this, 
-					getValidationTextRange()) 
+					new String[] {this.fileName},
+					this,
+					this.getValidationTextRange()
+				)
 			);
+			return;
 		}
-	}
-	
-	protected void addInvalidMappingFileContentMessage(List<IMessage> messages) {
-		if (getOrmXml() != null 
-				&& getOrmXml().getEntityMappings() == null) {
+
+		if (this.ormXml.getEntityMappings() == null) {
 			messages.add(
 				DefaultJpaValidationMessages.buildMessage(
 					IMessage.HIGH_SEVERITY,
 					JpaValidationMessages.PERSISTENCE_UNIT_INVALID_MAPPING_FILE,
-					new String[] {getFileName()}, 
+					new String[] {this.fileName},
 					this,
-					getValidationTextRange())
+					this.getValidationTextRange()
+				)
 			);
 		}
-	}
 
-	@Override
-	public void toString(StringBuilder sb) {
-		super.toString(sb);
-		sb.append(getFileName());
-	}
-	
-	public void dispose() {
-		if (getOrmXml() != null) {
-			getOrmXml().dispose();
-		}
+		this.ormXml.validate(messages);
 	}
+
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericPersistence.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericPersistence.java
index 9da975a37c..26fc0a6c8f 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericPersistence.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericPersistence.java
@@ -51,16 +51,15 @@ public class GenericPersistence extends AbstractPersistenceJpaContextNode
 	// **************** persistence units **************************************
 	
 	public ListIterator<PersistenceUnit> persistenceUnits() {
-		if (persistenceUnit == null) {
-			return EmptyListIterator.instance();
-		}
-		else {
-			return new SingleElementListIterator<PersistenceUnit>(persistenceUnit);
-		}
+		return (this.persistenceUnit == null) ? EmptyListIterator.<PersistenceUnit>instance() : this.persistenceUnits_();
+	}
+	
+	protected ListIterator<PersistenceUnit> persistenceUnits_() {
+		return new SingleElementListIterator<PersistenceUnit>(this.persistenceUnit);
 	}
 	
 	public int persistenceUnitsSize() {
-		return (persistenceUnit == null) ? 0 : 1;
+		return (this.persistenceUnit == null) ? 0 : 1;
 	}
 	
 	public PersistenceUnit addPersistenceUnit() {
@@ -68,54 +67,57 @@ public class GenericPersistence extends AbstractPersistenceJpaContextNode
 	}
 	
 	public PersistenceUnit addPersistenceUnit(int index) {
-		if (index > 0 || persistenceUnit != null) {
-			throw new IllegalStateException("This implementation does not support multiple persistence units.");
+		if (index > 0 || this.persistenceUnit != null) {
+			throw new IllegalStateException("This implementation does not support multiple persistence units."); //$NON-NLS-1$
 		}
 		XmlPersistenceUnit xmlPersistenceUnit = PersistenceFactory.eINSTANCE.createXmlPersistenceUnit();
-		persistenceUnit = createPersistenceUnit(xmlPersistenceUnit);
-		xmlPersistence.getPersistenceUnits().add(xmlPersistenceUnit);
-		fireItemAdded(PERSISTENCE_UNITS_LIST, index, persistenceUnit);
-		return persistenceUnit;
+		this.persistenceUnit = createPersistenceUnit(xmlPersistenceUnit);
+		this.xmlPersistence.getPersistenceUnits().add(xmlPersistenceUnit);
+		fireItemAdded(PERSISTENCE_UNITS_LIST, index, this.persistenceUnit);
+		return this.persistenceUnit;
 	}
 	
-	public void removePersistenceUnit(PersistenceUnit persistenceUnit) {
+	public void removePersistenceUnit(PersistenceUnit pu) {
+		if (pu != this.persistenceUnit) {
+			throw new IllegalArgumentException("Invalid persistence unit: " + pu); //$NON-NLS-1$
+		}
 		removePersistenceUnit(0);
 	}
 	
 	public void removePersistenceUnit(int index) {
-		if (index > 0 ) {
-			throw new IllegalArgumentException(new Integer(index).toString());
+		if (index > 0 || this.persistenceUnit == null) {
+			throw new IndexOutOfBoundsException("index: " + index); //$NON-NLS-1$
 		}
-		PersistenceUnit oldPersistenceUnit = persistenceUnit;
-		persistenceUnit.dispose();
-		persistenceUnit = null;
-		xmlPersistence.getPersistenceUnits().remove(index);
+		PersistenceUnit oldPersistenceUnit = this.persistenceUnit;
+		this.persistenceUnit.dispose();
+		this.persistenceUnit = null;
+		this.xmlPersistence.getPersistenceUnits().remove(index);
 		fireItemRemoved(PERSISTENCE_UNITS_LIST, index, oldPersistenceUnit);
 	}
 	
 	protected void addPersistenceUnit_(PersistenceUnit newPersistenceUnit) {
-		persistenceUnit = newPersistenceUnit;
-		fireItemAdded(PERSISTENCE_UNITS_LIST, 0, persistenceUnit);
+		this.persistenceUnit = newPersistenceUnit;
+		fireItemAdded(PERSISTENCE_UNITS_LIST, 0, this.persistenceUnit);
 	}
 	
 	protected void removePersistenceUnit_(PersistenceUnit oldPersistenceUnit) {
-		persistenceUnit.dispose();
-		persistenceUnit = null;
+		this.persistenceUnit.dispose();
+		this.persistenceUnit = null;
 		fireItemRemoved(PERSISTENCE_UNITS_LIST, 0, oldPersistenceUnit);
 	}
 	
 	
 	// **************** updating ***********************************************
 	
-	protected void initialize(XmlPersistence xmlPersistence) {
-		this.xmlPersistence = xmlPersistence;
-		initializePersistenceUnits(xmlPersistence);
+	protected void initialize(XmlPersistence persistence) {
+		this.xmlPersistence = persistence;
+		initializePersistenceUnits(persistence);
 	}
 	
 	protected void initializePersistenceUnits(XmlPersistence persistence) {
 		// only adding one here, until we support multiple persistence units
-		if (xmlPersistence.getPersistenceUnits().size() > 0) {
-			persistenceUnit = createPersistenceUnit(persistence.getPersistenceUnits().get(0));
+		if (this.xmlPersistence.getPersistenceUnits().size() > 0) {
+			this.persistenceUnit = createPersistenceUnit(persistence.getPersistenceUnits().get(0));
 		}
 	}
 	
@@ -126,12 +128,12 @@ public class GenericPersistence extends AbstractPersistenceJpaContextNode
 			xmlPersistenceUnit = persistence.getPersistenceUnits().get(0);
 		}
 				
-		if (persistenceUnit != null) {
+		if (this.persistenceUnit != null) {
 			if (xmlPersistenceUnit != null) {
-				persistenceUnit.update(xmlPersistenceUnit);
+				this.persistenceUnit.update(xmlPersistenceUnit);
 			}
 			else {
-				removePersistenceUnit_(persistenceUnit);
+				removePersistenceUnit_(this.persistenceUnit);
 			}
 		}
 		else {
@@ -150,78 +152,76 @@ public class GenericPersistence extends AbstractPersistenceJpaContextNode
 	
 	@Override
 	public PersistenceUnit getPersistenceUnit() {
-		throw new UnsupportedOperationException("No PersistenceUnit in this context");
+		throw new UnsupportedOperationException("No PersistenceUnit in this context"); //$NON-NLS-1$
 	}
 	
 	public JpaStructureNode getStructureNode(int textOffset) {
-		for (PersistenceUnit persistenceUnit : CollectionTools.iterable(persistenceUnits())) {
-			if (persistenceUnit.containsOffset(textOffset)) {
-				return persistenceUnit.getStructureNode(textOffset);
+		for (PersistenceUnit pu : CollectionTools.iterable(persistenceUnits())) {
+			if (pu.containsOffset(textOffset)) {
+				return pu.getStructureNode(textOffset);
 			}
 		}
 		return this;
 	}
 	
 	public boolean containsOffset(int textOffset) {
-		if (xmlPersistence == null) {
-			return false;
-		}
-		return xmlPersistence.containsOffset(textOffset);
+		return (this.xmlPersistence == null) ? false : this.xmlPersistence.containsOffset(textOffset);
 	}
 	
 	public TextRange getSelectionTextRange() {
-		return xmlPersistence.getSelectionTextRange();
+		return this.xmlPersistence.getSelectionTextRange();
 	}
 	
 	public TextRange getValidationTextRange() {
-		return xmlPersistence.getValidationTextRange();
+		return this.xmlPersistence.getValidationTextRange();
+	}
+
+	public void dispose() {
+		for (PersistenceUnit pu : CollectionTools.iterable(persistenceUnits())) {
+			pu.dispose();
+		}
 	}
 
 
+	// ********** validation **********
+
 	@Override
-	public void addToMessages(List<IMessage> messages) {
-		super.addToMessages(messages);
-		//persistence root validation
-		addNoPersistenceUnitMessage(messages);
-		
-		// note to neil (or whomever): extraneous persistence units can be
-		// accessed through the XmlPersistence resource object
-		addMultiplePersistenceUnitMessage(messages);
-		
-		
-		//persistence unit validation
-		if (persistenceUnit != null) {
-			persistenceUnit.addToMessages(messages);
-		}
+	public void validate(List<IMessage> messages) {
+		super.validate(messages);
+		this.checkForMultiplePersistenceUnits(messages);
+		this.validatePersistenceUnit(messages);
 	}
-	
-	protected void addNoPersistenceUnitMessage(List<IMessage> messages) {
-		if (persistenceUnit == null) {
+
+	/**
+	 * extraneous persistence units can be
+	 * accessed through the XmlPersistence resource object
+	 */
+	protected void checkForMultiplePersistenceUnits(List<IMessage> messages) {
+		if (this.xmlPersistence.getPersistenceUnits().size() > 1) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.PERSISTENCE_NO_PERSISTENCE_UNIT,
-						this, 
-						this.getValidationTextRange())
-				);
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.NORMAL_SEVERITY,
+					JpaValidationMessages.PERSISTENCE_MULTIPLE_PERSISTENCE_UNITS,
+					this, 
+					this.getValidationTextRange()
+				)
+			);
 		}
 	}
 	
-	protected void addMultiplePersistenceUnitMessage(List<IMessage> messages) {
-		if (xmlPersistence.getPersistenceUnits().size() > 1) {
+	protected void validatePersistenceUnit(List<IMessage> messages) {
+		if (this.persistenceUnit == null) {
 			messages.add(
 				DefaultJpaValidationMessages.buildMessage(
-						IMessage.NORMAL_SEVERITY,
-						JpaValidationMessages.PERSISTENCE_MULTIPLE_PERSISTENCE_UNITS,
-						this, 
-						this.getValidationTextRange())
-				);
-		}
-	}
-	
-	public void dispose() {
-		for (PersistenceUnit persistenceUnit : CollectionTools.iterable(persistenceUnits())) {
-			persistenceUnit.dispose();
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.PERSISTENCE_NO_PERSISTENCE_UNIT,
+					this, 
+					this.getValidationTextRange()
+				)
+			);
+			return;
 		}
+		this.persistenceUnit.validate(messages);
 	}
+
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericPersistenceUnit.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericPersistenceUnit.java
index b5e46f0a6d..3a899f9480 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericPersistenceUnit.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericPersistenceUnit.java
@@ -11,18 +11,28 @@ package org.eclipse.jpt.core.internal.context.persistence;
 
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;
 import java.util.NoSuchElementException;
 import java.util.Set;
+
+import org.eclipse.jdt.core.dom.CompilationUnit;
 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.GeneratedValue;
 import org.eclipse.jpt.core.context.Generator;
 import org.eclipse.jpt.core.context.PersistentType;
 import org.eclipse.jpt.core.context.Query;
+import org.eclipse.jpt.core.context.java.JavaGeneratedValue;
+import org.eclipse.jpt.core.context.java.JavaGenerator;
+import org.eclipse.jpt.core.context.java.JavaQuery;
+import org.eclipse.jpt.core.context.orm.OrmGeneratedValue;
+import org.eclipse.jpt.core.context.orm.OrmGenerator;
 import org.eclipse.jpt.core.context.orm.OrmPersistentType;
+import org.eclipse.jpt.core.context.orm.OrmQuery;
 import org.eclipse.jpt.core.context.orm.PersistenceUnitDefaults;
 import org.eclipse.jpt.core.context.persistence.ClassRef;
 import org.eclipse.jpt.core.context.persistence.MappingFileRef;
@@ -47,6 +57,7 @@ import org.eclipse.jpt.utility.internal.HashBag;
 import org.eclipse.jpt.utility.internal.iterators.CloneIterator;
 import org.eclipse.jpt.utility.internal.iterators.CloneListIterator;
 import org.eclipse.jpt.utility.internal.iterators.EmptyIterator;
+import org.eclipse.jpt.utility.internal.iterators.FilteringIterator;
 import org.eclipse.jpt.utility.internal.iterators.ReadOnlyCompositeListIterator;
 import org.eclipse.jpt.utility.internal.iterators.TransformationIterator;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
@@ -679,7 +690,7 @@ public class GenericPersistenceUnit extends AbstractPersistenceJpaContextNode
 	}
 	
 	
-	// **************** global generator and query support *********************
+	// **************** generators *********************
 	
 	public void addGenerator(Generator generator) {
 		this.generators.add(generator);
@@ -688,6 +699,110 @@ public class GenericPersistenceUnit extends AbstractPersistenceJpaContextNode
 	public ListIterator<Generator> allGenerators() {
 		return new CloneListIterator<Generator>(this.generators);
 	}
+
+	protected Iterator<String> allGeneratorNames() {
+		return new TransformationIterator<Generator, String>(this.allGenerators()) {
+			@Override
+			protected String transform(Generator generator) {
+				return generator.getName();
+			}
+		};
+	}
+	
+	protected Iterator<String> allNonNullGeneratorNames() {
+		return new FilteringIterator<String, String>(this.allGeneratorNames()) {
+			@Override
+			protected boolean accept(String generatorName) {
+				return generatorName != null;
+			}
+		};
+	}
+	
+	public String[] uniqueGeneratorNames() {
+		HashSet<String> names = CollectionTools.set(this.allNonNullGeneratorNames());
+		return names.toArray(new String[names.size()]);
+	}
+	
+	public void validateGenerators(OrmGeneratorHolder generatorHolder, List<IMessage> messages) {
+		ArrayList<Generator> allGenerators = CollectionTools.list(this.allGenerators());
+		for (Iterator<OrmGenerator> stream = generatorHolder.generators(); stream.hasNext(); ) {
+			OrmGenerator generator = stream.next();
+			this.validateGenerator(generator, generator.getNameTextRange(), allGenerators, messages);
+		}
+	}
+
+	public void validateGenerators(JavaGeneratorHolder generatorHolder, List<IMessage> messages, CompilationUnit astRoot) {
+		ArrayList<Generator> allGenerators = CollectionTools.list(this.allGenerators());
+		for (Iterator<JavaGenerator> stream = generatorHolder.generators(); stream.hasNext(); ) {
+			JavaGenerator generator = stream.next();
+			this.validateGenerator(generator, generator.getNameTextRange(astRoot), allGenerators, messages);
+		}
+	}
+	
+	protected void validateGenerator(Generator generator, TextRange generatorNameTextRange, ArrayList<Generator> allGenerators, List<IMessage> messages) {
+		for (Generator otherGenerator : allGenerators) {
+			if (this.generatorsAreDuplicates(generator, otherGenerator)) {
+				messages.add(
+					DefaultJpaValidationMessages.buildMessage(
+						IMessage.HIGH_SEVERITY,
+						JpaValidationMessages.GENERATOR_DUPLICATE_NAME,
+						new String[] {generator.getName()},
+						generator,
+						generatorNameTextRange
+					)
+				);
+			}
+		}
+	}
+
+	protected boolean generatorsAreDuplicates(Generator generator, Generator otherGenerator) {
+		if (otherGenerator == generator) {
+			return false;
+		}
+		if (otherGenerator.overrides(generator)) {
+			return false;
+		}
+		String otherName = otherGenerator.getName();
+		return (otherName != null) && otherName.equals(generator.getName());
+	}
+
+	public void validateGeneratedValue(OrmGeneratedValueHolder generatedValueHolder, List<IMessage> messages) {
+		OrmGeneratedValue generatedValue = generatedValueHolder.getGeneratedValue();
+		if (generatedValue != null) {
+			this.validateGeneratedValue(generatedValue, generatedValue.getGeneratorTextRange(), generatedValueHolder, messages);
+		}
+	}
+
+	public void validateGeneratedValue(JavaGeneratedValueHolder generatedValueHolder, List<IMessage> messages, CompilationUnit astRoot) {
+		JavaGeneratedValue generatedValue = generatedValueHolder.getGeneratedValue();
+		if (generatedValue != null) {
+			this.validateGeneratedValue(generatedValue, generatedValue.getGeneratorTextRange(astRoot), generatedValueHolder, messages);
+		}
+	}
+
+	protected void validateGeneratedValue(GeneratedValue generatedValue, TextRange generatedValueGeneratorTextRange, Object holder, List<IMessage> messages) {
+		String generatorName = generatedValue.getGenerator();
+		if (generatorName == null) {
+			return;
+		}
+		for (Iterator<Generator> stream = this.allGenerators(); stream.hasNext(); ) {
+			if (generatorName.equals(stream.next().getName())) {
+				return;  // match found
+			}
+		}
+		messages.add(
+			DefaultJpaValidationMessages.buildMessage(
+				IMessage.HIGH_SEVERITY,
+				JpaValidationMessages.ID_MAPPING_UNRESOLVED_GENERATOR_NAME,
+				new String[] {generatorName},
+				holder,
+				generatedValueGeneratorTextRange
+			)
+		);
+	}
+
+	
+	// **************** queries *********************
 	
 	public void addQuery(Query query) {
 		this.queries.add(query);
@@ -696,7 +811,50 @@ public class GenericPersistenceUnit extends AbstractPersistenceJpaContextNode
 	public ListIterator<Query> allQueries() {
 		return new CloneListIterator<Query>(this.queries);
 	}
+
+	public void validateQueries(OrmQueryHolder queryHolder, List<IMessage> messages) {
+		ArrayList<Query> allQueries = CollectionTools.list(this.allQueries());
+		for (Iterator<OrmQuery> stream = queryHolder.queries(); stream.hasNext(); ) {
+			OrmQuery query = stream.next();
+			this.validateQuery(query, query.getNameTextRange(), allQueries, messages);
+		}
+	}
+
+	public void validateQueries(JavaQueryHolder queryHolder, List<IMessage> messages, CompilationUnit astRoot) {
+		ArrayList<Query> allQueries = CollectionTools.list(this.allQueries());
+		for (Iterator<JavaQuery> stream = queryHolder.queries(); stream.hasNext(); ) {
+			JavaQuery query = stream.next();
+			this.validateQuery(query, query.getNameTextRange(astRoot), allQueries, messages);
+		}
+	}
 	
+	protected void validateQuery(Query query, TextRange queryNameTextRange, ArrayList<Query> allQueries, List<IMessage> messages) {
+		for (Query otherQuery : allQueries) {
+			if (this.queriesAreDuplicates(query, otherQuery)) {
+				messages.add(
+					DefaultJpaValidationMessages.buildMessage(
+						IMessage.HIGH_SEVERITY,
+						JpaValidationMessages.QUERY_DUPLICATE_NAME,
+						new String[] {query.getName()},
+						query,
+						queryNameTextRange
+					)
+				);
+			}
+		}
+	}
+
+	protected boolean queriesAreDuplicates(Query query, Query otherQuery) {
+		if (otherQuery == query) {
+			return false;
+		}
+		if (otherQuery.overrides(query)) {
+			return false;
+		}
+		String otherName = otherQuery.getName();
+		return (otherName != null) && otherName.equals(query.getName());
+	}
+
 
 	// **************** updating ***********************************************
 	
@@ -973,8 +1131,8 @@ public class GenericPersistenceUnit extends AbstractPersistenceJpaContextNode
 				return true;
 			}
 		}
-		for (MappingFileRef mappingFileRef : CollectionTools.iterable(mappingFileRefs())) {
-			if (mappingFileRef.getPersistentType(className) != null) {
+		for (Iterator<MappingFileRef> stream = this.mappingFileRefs(); stream.hasNext(); ) {
+			if (stream.next().getPersistentType(className) != null) {
 				return true;
 			}
 		}
@@ -1059,23 +1217,22 @@ public class GenericPersistenceUnit extends AbstractPersistenceJpaContextNode
 	// ********** Validation ***********************************************
 	
 	@Override
-	public void addToMessages(List<IMessage> messages) {
-		super.addToMessages(messages);
-		addMappingFileMessages(messages);	
-		addClassMessages(messages);
+	public void validate(List<IMessage> messages) {
+		super.validate(messages);
+		this.validateMappingFiles(messages);	
+		this.validateClassRefs(messages);
 	}
 	
-	protected void addMappingFileMessages(List<IMessage> messages) {
-		addMultipleMetadataMessages(messages);
-		addDuplicateMappingFileMessages(messages);
-		
-		for (Iterator<MappingFileRef> stream =  mappingFileRefs(); stream.hasNext();) {
-			stream.next().addToMessages(messages);
+	protected void validateMappingFiles(List<IMessage> messages) {
+		this.checkForMultiplePersistenceUnitDefaults(messages);
+		this.checkForDuplicateMappingFiles(messages);
+		for (Iterator<MappingFileRef> stream = this.mappingFileRefs(); stream.hasNext();) {
+			stream.next().validate(messages);
 		}
 	}
 	
-	protected void addMultipleMetadataMessages(List<IMessage> messages) {
-		Collection<PersistenceUnitDefaults> puDefaultsCollection = persistenceUnitDefaultsForValidation();
+	protected void checkForMultiplePersistenceUnitDefaults(List<IMessage> messages) {
+		Collection<PersistenceUnitDefaults> puDefaultsCollection = this.buildPersistenceUnitDefaultsCollection();
 		if (puDefaultsCollection.size() > 1) {
 			for (PersistenceUnitDefaults puDefaults : puDefaultsCollection) {
 				messages.add(
@@ -1083,72 +1240,77 @@ public class GenericPersistenceUnit extends AbstractPersistenceJpaContextNode
 						IMessage.HIGH_SEVERITY,
 						JpaValidationMessages.ENTITY_MAPPINGS_MULTIPLE_METADATA,
 						new String[] {this.getName()},
-						puDefaults)
+						puDefaults
+					)
 				);
 			}
 		}
 	}
-	
-	protected void addDuplicateMappingFileMessages(List<IMessage> messages) {
-		HashBag<String> fileBag = new HashBag<String>(
-				CollectionTools.collection(
-						new TransformationIterator<MappingFileRef, String>(this.mappingFileRefs()) {
-							@Override
-							protected String transform(MappingFileRef mappingFileRef) {
-								return mappingFileRef.getFileName();
-							}
-						}
-				)
-		);
+
+	protected void checkForDuplicateMappingFiles(List<IMessage> messages) {
+		HashBag<String> fileNames = new HashBag<String>();
+		CollectionTools.addAll(fileNames, this.mappingFileRefNames());
 		for (MappingFileRef mappingFileRef : CollectionTools.iterable(this.mappingFileRefs())) {
-			if (fileBag.count(mappingFileRef.getFileName()) > 1) {
+			String fileName = mappingFileRef.getFileName();
+			if (fileNames.count(fileName) > 1) {
 				messages.add(
 					DefaultJpaValidationMessages.buildMessage(
 						IMessage.HIGH_SEVERITY,
 						JpaValidationMessages.PERSISTENCE_UNIT_DUPLICATE_MAPPING_FILE,
-						new String[] {mappingFileRef.getFileName()}, 
+						new String[] {fileName}, 
 						mappingFileRef, 
-						mappingFileRef.getValidationTextRange())
+						mappingFileRef.getValidationTextRange()
+					)
 				);
 			}
 		}
 	}
 		
-	protected void addClassMessages(List<IMessage> messages) {
-		addDuplicateClassMessages(messages);
-		
-		for (ClassRef classRef : CollectionTools.iterable(classRefs())) {
-			classRef.addToMessages(messages);
-		}
+	protected Iterator<String> mappingFileRefNames() {
+		return new TransformationIterator<MappingFileRef, String>(this.mappingFileRefs()) {
+			@Override
+			protected String transform(MappingFileRef mappingFileRef) {
+				return mappingFileRef.getFileName();
+			}
+		};
 	}
 	
-	protected void addDuplicateClassMessages(List<IMessage> messages) {
-		HashBag<String> classNameBag = new HashBag<String>(
-				CollectionTools.collection(
-						new TransformationIterator<ClassRef, String>(this.classRefs()) {
-							@Override
-							protected String transform(ClassRef classRef) {
-								return classRef.getClassName();
-							}
-						}
-				)
-		);
-		for (ClassRef javaClassRef : CollectionTools.iterable(this.classRefs())) {
-			if (javaClassRef.getClassName() != null
-					&& classNameBag.count(javaClassRef.getClassName()) > 1) {
+	protected void validateClassRefs(List<IMessage> messages) {
+		this.checkForDuplicateClasses(messages);
+		for (Iterator<ClassRef> stream = this.classRefs(); stream.hasNext(); ) {
+			stream.next().validate(messages);
+		}
+	}
+
+	protected void checkForDuplicateClasses(List<IMessage> messages) {
+		HashBag<String> classNames = new HashBag<String>();
+		CollectionTools.addAll(classNames, this.classRefNames());
+		for (ClassRef classRef : CollectionTools.iterable(this.classRefs())) {
+			String className = classRef.getClassName();
+			if ((className != null) && (classNames.count(className) > 1)) {
 				messages.add(
 					DefaultJpaValidationMessages.buildMessage(
 						IMessage.HIGH_SEVERITY,
 						JpaValidationMessages.PERSISTENCE_UNIT_DUPLICATE_CLASS,
-						new String[] {javaClassRef.getClassName()}, 
-						javaClassRef, 
-						javaClassRef.getValidationTextRange())
+						new String[] {className}, 
+						classRef, 
+						classRef.getValidationTextRange()
+					)
 				);
 			}
 		}
 	}
 	
-	private Collection<PersistenceUnitDefaults> persistenceUnitDefaultsForValidation() {
+	protected Iterator<String> classRefNames() {
+		return new TransformationIterator<ClassRef, String>(this.classRefs()) {
+			@Override
+			protected String transform(ClassRef classRef) {
+				return classRef.getClassName();
+			}
+		};
+	}
+
+	protected Collection<PersistenceUnitDefaults> buildPersistenceUnitDefaultsCollection() {
 		ArrayList<PersistenceUnitDefaults> result = new ArrayList<PersistenceUnitDefaults>();
 		for (Iterator<MappingFileRef> stream = this.mappingFileRefs(); stream.hasNext(); ) {
 			PersistenceUnitDefaults defaults = stream.next().getPersistenceUnitDefaults();
@@ -1162,8 +1324,8 @@ public class GenericPersistenceUnit extends AbstractPersistenceJpaContextNode
 	//*************************************
 	
 	public PersistentType getPersistentType(String fullyQualifiedTypeName) {
-		for (MappingFileRef mappingFileRef : CollectionTools.iterable(mappingFileRefs())) {
-			OrmPersistentType ormPersistentType = mappingFileRef.getPersistentType(fullyQualifiedTypeName);
+		for (Iterator<MappingFileRef> stream = this.mappingFileRefs(); stream.hasNext(); ) {
+			OrmPersistentType ormPersistentType = stream.next().getPersistentType(fullyQualifiedTypeName);
 			if (ormPersistentType != null) {
 				return ormPersistentType;
 			}
@@ -1212,11 +1374,11 @@ public class GenericPersistenceUnit extends AbstractPersistenceJpaContextNode
 	}
 	
 	public void dispose() {
-		for (ClassRef classRef : CollectionTools.iterable(classRefs())) {
-			classRef.dispose();
+		for (Iterator<ClassRef> stream = this.classRefs(); stream.hasNext(); ) {
+			stream.next().dispose();
 		}
-		for (MappingFileRef mappingFileRef : CollectionTools.iterable(mappingFileRefs())) {
-			mappingFileRef.dispose();
+		for (Iterator<MappingFileRef> stream = this.mappingFileRefs(); stream.hasNext(); ) {
+			stream.next().dispose();
 		}
 	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericPersistenceXml.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericPersistenceXml.java
index 0789b2034b..6a9936a910 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericPersistenceXml.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/GenericPersistenceXml.java
@@ -25,7 +25,11 @@ import org.eclipse.jpt.core.resource.persistence.XmlPersistence;
 import org.eclipse.jpt.core.utility.TextRange;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
-public class GenericPersistenceXml extends AbstractPersistenceJpaContextNode
+/**
+ * 
+ */
+public class GenericPersistenceXml
+	extends AbstractPersistenceJpaContextNode
 	implements PersistenceXml
 {
 	protected PersistenceResource persistenceResource;
@@ -50,71 +54,71 @@ public class GenericPersistenceXml extends AbstractPersistenceJpaContextNode
 	
 	@Override
 	public IResource getResource() {
-		return persistenceResource.getFile();
+		return this.persistenceResource.getFile();
 	}
 	
 	// **************** persistence ********************************************
 	
 	public Persistence getPersistence() {
-		return persistence;
+		return this.persistence;
 	}
 	
 	public Persistence addPersistence() {
-		if (persistence != null) {
+		if (this.persistence != null) {
 			throw new IllegalStateException();
 		}
 		
 		XmlPersistence xmlPersistence = PersistenceFactory.eINSTANCE.createXmlPersistence();
-		persistence = buildPersistence(xmlPersistence);
-		persistenceResource.getContents().add(xmlPersistence);
-		firePropertyChanged(PERSISTENCE_PROPERTY, null, persistence);
-		return persistence;
+		this.persistence = buildPersistence(xmlPersistence);
+		this.persistenceResource.getContents().add(xmlPersistence);
+		firePropertyChanged(PERSISTENCE_PROPERTY, null, this.persistence);
+		return this.persistence;
 	}
 	
 	public void removePersistence() {
-		if (persistence == null) {
+		if (this.persistence == null) {
 			throw new IllegalStateException();
 		}
 		getJpaFile(this.persistenceResource.getResourceModel()).removeRootStructureNode(this.persistenceResource);
 		this.persistence.dispose();
-		Persistence oldPersistence = persistence;
-		persistence = null;
-		XmlPersistence xmlPersistence = persistenceResource.getPersistence();
-		persistenceResource.getContents().remove(xmlPersistence);
+		Persistence oldPersistence = this.persistence;
+		this.persistence = null;
+		XmlPersistence xmlPersistence = this.persistenceResource.getPersistence();
+		this.persistenceResource.getContents().remove(xmlPersistence);
 		firePropertyChanged(PERSISTENCE_PROPERTY, oldPersistence, null);
 	}
 	
 	protected void setPersistence_(Persistence newPersistence) {
-		Persistence oldPersistence = persistence;
-		persistence = newPersistence;
+		Persistence oldPersistence = this.persistence;
+		this.persistence = newPersistence;
 		firePropertyChanged(PERSISTENCE_PROPERTY, oldPersistence, newPersistence);
 	}
 	
 	
 	// **************** updating ***********************************************
 	
-	protected void initialize(PersistenceResource persistenceResource) {
-		this.persistenceResource = persistenceResource;
-		if (persistenceResource.getPersistence() != null) {
-			this.persistence = buildPersistence(persistenceResource.getPersistence());
+	protected void initialize(PersistenceResource pr) {
+		this.persistenceResource = pr;
+		if (pr.getPersistence() != null) {
+			this.persistence = buildPersistence(pr.getPersistence());
 		}
 	}
 
-	public void update(PersistenceResource persistenceResource) {
-		this.persistenceResource = persistenceResource;
-		if (persistenceResource.getPersistence() != null) {
+	public void update(PersistenceResource pr) {
+		this.persistenceResource = pr;
+		if (pr.getPersistence() != null) {
 			if (this.persistence != null) {
-				getJpaFile(this.persistenceResource.getResourceModel()).addRootStructureNode(this.persistenceResource, this.persistence);
-				this.persistence.update(persistenceResource.getPersistence());
+				this.getJpaFile(this.persistenceResource.getResourceModel()).addRootStructureNode(this.persistenceResource, this.persistence);
+				this.persistence.update(pr.getPersistence());
 			}
 			else {
-				setPersistence_(buildPersistence(persistenceResource.getPersistence()));
+				setPersistence_(buildPersistence(pr.getPersistence()));
 			}
 		}
 		else {
-			if (getPersistence() != null) {
-				getJpaFile(this.persistenceResource.getResourceModel()).removeRootStructureNode(this.persistenceResource);
-				getPersistence().dispose();
+			if (this.persistence != null) {
+				this.getJpaFile(this.persistenceResource.getResourceModel()).removeRootStructureNode(this.persistenceResource);
+				this.persistence.dispose();
 			}
 			setPersistence_(null);
 		}
@@ -129,13 +133,13 @@ public class GenericPersistenceXml extends AbstractPersistenceJpaContextNode
 	
 	@Override
 	public PersistenceUnit getPersistenceUnit() {
-		throw new UnsupportedOperationException("No PersistenceUnit in this context");
+		throw new UnsupportedOperationException("No Persistence Unit in this context"); //$NON-NLS-1$
 	}
 	
 	
 	public JpaStructureNode getStructureNode(int textOffset) {
-		if (persistence.containsOffset(textOffset)) {
-			return persistence.getStructureNode(textOffset);
+		if (this.persistence.containsOffset(textOffset)) {
+			return this.persistence.getStructureNode(textOffset);
 		}
 		return this;
 	}
@@ -152,28 +156,22 @@ public class GenericPersistenceXml extends AbstractPersistenceJpaContextNode
 	
 	// **************** validation *********************************************
 	
-	private boolean okToContinueValidation = true;
-
 	@Override
-	public void addToMessages(List<IMessage> messages) {
-		super.addToMessages(messages);
-		addInvalidPersistenceXmlContentMessage(messages);
-		
-		if (okToContinueValidation){
-			getPersistence().addToMessages(messages);
-		}
-	}
-	
-	protected void addInvalidPersistenceXmlContentMessage(List<IMessage> messages) {
+	public void validate(List<IMessage> messages) {
+		super.validate(messages);
+
 		if (this.persistence == null) {
 			messages.add(
-					DefaultJpaValidationMessages.buildMessage(
-						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.PERSISTENCE_XML_INVALID_CONTENT,
-						this)
-				);
-			okToContinueValidation = false;
+				DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.PERSISTENCE_XML_INVALID_CONTENT,
+					this
+				)
+			);
+			return;
 		}
+
+		this.persistence.validate(messages);
 	}
 
 	public void dispose() {
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/operations/OrmFileCreationDataModelProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/operations/OrmFileCreationDataModelProvider.java
index 8a4d527887..beb5a513fd 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/operations/OrmFileCreationDataModelProvider.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/operations/OrmFileCreationDataModelProvider.java
@@ -398,7 +398,7 @@ public class OrmFileCreationDataModelProvider extends AbstractDataModelProvider
 		if (jpaProject == null) {
 			return null;
 		}
-		PersistenceXml persistenceXml = jpaProject.getRootContext().getPersistenceXml();
+		PersistenceXml persistenceXml = jpaProject.getRootContextNode().getPersistenceXml();
 		if (persistenceXml == null) {
 			return null;
 		}
@@ -417,7 +417,7 @@ public class OrmFileCreationDataModelProvider extends AbstractDataModelProvider
 		JpaProject jpaProject = 
 			(StringTools.stringIsEmpty(pUnitName)) ? null : getJpaProject();
 		PersistenceXml persistenceXml = 
-			(jpaProject == null) ? null : jpaProject.getRootContext().getPersistenceXml();
+			(jpaProject == null) ? null : jpaProject.getRootContextNode().getPersistenceXml();
 		Persistence persistence = 
 			(persistenceXml == null) ? null : persistenceXml.getPersistence();
 		if (persistence != null) {
@@ -452,7 +452,7 @@ public class OrmFileCreationDataModelProvider extends AbstractDataModelProvider
 				protected Iterator<PersistenceUnit> transform(IProject jpaIProject) {
 					JpaProject jpaProject = JptCorePlugin.getJpaProject(jpaIProject);
 					PersistenceXml persistenceXml = 
-						(jpaProject == null) ? null : jpaProject.getRootContext().getPersistenceXml();
+						(jpaProject == null) ? null : jpaProject.getRootContextNode().getPersistenceXml();
 					Persistence persistence = 
 						(persistenceXml == null) ? null : persistenceXml.getPersistence();
 					return (persistence == null) ? EmptyIterator.<PersistenceUnit>instance() : persistence.persistenceUnits();
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/operations/OrmFileCreationOperation.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/operations/OrmFileCreationOperation.java
index ca1d1c6134..326d702b02 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/operations/OrmFileCreationOperation.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/operations/OrmFileCreationOperation.java
@@ -78,7 +78,7 @@ public class OrmFileCreationOperation extends AbstractDataModelOperation
 	private PersistenceUnit getPersistenceUnit() throws ExecutionException {
 		String pUnitName = getDataModel().getStringProperty(PERSISTENCE_UNIT);
 		JpaProject jpaProject = getJpaProject();
-		PersistenceXml persistenceXml = jpaProject.getRootContext().getPersistenceXml();
+		PersistenceXml persistenceXml = jpaProject.getRootContextNode().getPersistenceXml();
 		if (persistenceXml == null) {
 			throw new ExecutionException("Project does not have a persistence.xml file");
 		}
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 454877278d..a3a2e7d34f 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
@@ -15,6 +15,7 @@ import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;
+
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.Platform;
@@ -55,7 +56,6 @@ import org.eclipse.jpt.db.DatabaseFinder;
 import org.eclipse.jpt.db.JptDbPlugin;
 import org.eclipse.jpt.utility.internal.iterators.CloneIterator;
 import org.eclipse.jpt.utility.internal.iterators.CloneListIterator;
-import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
 public class GenericJpaPlatform
 	implements JpaPlatform
@@ -331,13 +331,6 @@ public class GenericJpaPlatform
 	}
 
 
-	// **************** Validation *********************************************
-
-	public void addToMessages(JpaProject project, List<IMessage> messages) {
-		project.addToMessages(messages);
-	}
-
-
 	// **************** Database *********************************************
 
 	public ConnectionProfileFactory getConnectionProfileFactory() {
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/synch/SynchronizeClassesJob.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/synch/SynchronizeClassesJob.java
index 9ae194d51c..de759897b4 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/synch/SynchronizeClassesJob.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/synch/SynchronizeClassesJob.java
@@ -105,7 +105,7 @@ public class SynchronizeClassesJob extends WorkspaceJob
 	}
 	
 	private boolean mappingFileContains(JpaProject jpaProject, String fullyQualifiedTypeName) {
-		PersistenceXml persistenceXml = jpaProject.getRootContext().getPersistenceXml();
+		PersistenceXml persistenceXml = jpaProject.getRootContextNode().getPersistenceXml();
 		if (persistenceXml == null) {
 			return false;
 		}
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/EclipseLinkJavaCachingImpl.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/EclipseLinkJavaCachingImpl.java
index 7deeba51a1..659a759dc2 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/EclipseLinkJavaCachingImpl.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/EclipseLinkJavaCachingImpl.java
@@ -534,12 +534,12 @@ public class EclipseLinkJavaCachingImpl extends AbstractJavaJpaContextNode imple
 	}
 
 	@Override
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		super.addToMessages(messages, astRoot);
-		addExpiryMessages(messages, astRoot);
+	public void validate(List<IMessage> messages, CompilationUnit astRoot) {
+		super.validate(messages, astRoot);
+		this.validateExpiry(messages, astRoot);
 	}
 
-	protected void addExpiryMessages(List<IMessage> messages, CompilationUnit astRoot) {
+	protected void validateExpiry(List<IMessage> messages, CompilationUnit astRoot) {
 		CacheAnnotation cache = getCacheAnnotation();
 		if (cache.getExpiry() != null && cache.getExpiryTimeOfDay() != null) {
 			messages.add(
@@ -548,7 +548,8 @@ public class EclipseLinkJavaCachingImpl extends AbstractJavaJpaContextNode imple
 					EclipseLinkJpaValidationMessages.CACHE_EXPIRY_AND_EXPIRY_TIME_OF_DAY_BOTH_SPECIFIED,
 					new String[] {this.getParent().getPersistentType().getName()},
 					this, 
-					getValidationTextRange(astRoot))
+					getValidationTextRange(astRoot)
+				)
 			);
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/EclipseLinkJavaEntityImpl.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/EclipseLinkJavaEntityImpl.java
index 642a292d92..3362e3a71f 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/EclipseLinkJavaEntityImpl.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/EclipseLinkJavaEntityImpl.java
@@ -54,8 +54,8 @@ public class EclipseLinkJavaEntityImpl extends GenericJavaEntity implements Ecli
 	//********** Validation ********************************************
 
 	@Override
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		super.addToMessages(messages, astRoot);
-		getCaching().addToMessages(messages, astRoot);
+	public void validate(List<IMessage> messages, CompilationUnit astRoot) {
+		super.validate(messages, astRoot);
+		this.eclipseLinkCaching.validate(messages, astRoot);
 	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/EclipseLinkJavaMappedSuperclassImpl.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/EclipseLinkJavaMappedSuperclassImpl.java
index f745d99f86..0181df25b3 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/EclipseLinkJavaMappedSuperclassImpl.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/context/java/EclipseLinkJavaMappedSuperclassImpl.java
@@ -54,8 +54,8 @@ public class EclipseLinkJavaMappedSuperclassImpl extends GenericJavaMappedSuperc
 	//********** Validation ********************************************
 
 	@Override
-	public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) {
-		super.addToMessages(messages, astRoot);
-		getCaching().addToMessages(messages, astRoot);
+	public void validate(List<IMessage> messages, CompilationUnit astRoot) {
+		super.validate(messages, astRoot);
+		this.eclipseLinkCaching.validate(messages, astRoot);
 	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/ddlgen/EclipseLinkDDLGeneratorUi.java b/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/ddlgen/EclipseLinkDDLGeneratorUi.java
index 8db6f39213..0cc0c7502f 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/ddlgen/EclipseLinkDDLGeneratorUi.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.ui/src/org/eclipse/jpt/eclipselink/ui/internal/ddlgen/EclipseLinkDDLGeneratorUi.java
@@ -116,7 +116,7 @@ public class EclipseLinkDDLGeneratorUi
 	}
 
 	protected Persistence getPersistence() {
-		return this.project.getRootContext().getPersistenceXml().getPersistence();
+		return this.project.getRootContextNode().getPersistenceXml().getPersistence();
 	}
 
 	// ********** runnable **********
diff --git a/jpa/plugins/org.eclipse.jpt.ui/src/org/eclipse/jpt/ui/internal/editors/PersistenceEditor.java b/jpa/plugins/org.eclipse.jpt.ui/src/org/eclipse/jpt/ui/internal/editors/PersistenceEditor.java
index 95d9e9fec7..8f2a941dea 100644
--- a/jpa/plugins/org.eclipse.jpt.ui/src/org/eclipse/jpt/ui/internal/editors/PersistenceEditor.java
+++ b/jpa/plugins/org.eclipse.jpt.ui/src/org/eclipse/jpt/ui/internal/editors/PersistenceEditor.java
@@ -219,7 +219,7 @@ public class PersistenceEditor extends FormEditor
 		return new TransformationPropertyValueModel<JpaProject, JpaRootContextNode>(buildJpaProjectHolder()) {
 			@Override
 			protected JpaRootContextNode transform_(JpaProject value) {
-				return value.getRootContext();
+				return value.getRootContextNode();
 			}
 		};
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.ui/src/org/eclipse/jpt/ui/internal/mappings/details/GeneratedValueComposite.java b/jpa/plugins/org.eclipse.jpt.ui/src/org/eclipse/jpt/ui/internal/mappings/details/GeneratedValueComposite.java
index c5124bcd51..f2ad54542f 100644
--- a/jpa/plugins/org.eclipse.jpt.ui/src/org/eclipse/jpt/ui/internal/mappings/details/GeneratedValueComposite.java
+++ b/jpa/plugins/org.eclipse.jpt.ui/src/org/eclipse/jpt/ui/internal/mappings/details/GeneratedValueComposite.java
@@ -10,21 +10,19 @@
 package org.eclipse.jpt.ui.internal.mappings.details;
 
 import java.util.Collection;
+
 import org.eclipse.jpt.core.context.GeneratedValue;
 import org.eclipse.jpt.core.context.GenerationType;
-import org.eclipse.jpt.core.context.Generator;
 import org.eclipse.jpt.core.context.IdMapping;
 import org.eclipse.jpt.core.context.persistence.PersistenceUnit;
 import org.eclipse.jpt.ui.internal.JpaHelpContextIds;
 import org.eclipse.jpt.ui.internal.listeners.SWTListChangeListenerWrapper;
 import org.eclipse.jpt.ui.internal.listeners.SWTPropertyChangeListenerWrapper;
 import org.eclipse.jpt.ui.internal.mappings.JptUiMappingsMessages;
-import org.eclipse.jpt.ui.internal.widgets.FormPane;
 import org.eclipse.jpt.ui.internal.widgets.EnumFormComboViewer;
+import org.eclipse.jpt.ui.internal.widgets.FormPane;
 import org.eclipse.jpt.utility.internal.CollectionTools;
 import org.eclipse.jpt.utility.internal.StringTools;
-import org.eclipse.jpt.utility.internal.iterators.FilteringIterator;
-import org.eclipse.jpt.utility.internal.iterators.TransformationIterator;
 import org.eclipse.jpt.utility.internal.model.value.PropertyAspectAdapter;
 import org.eclipse.jpt.utility.model.event.ListChangeEvent;
 import org.eclipse.jpt.utility.model.event.PropertyChangeEvent;
@@ -408,22 +406,7 @@ public class GeneratedValueComposite extends FormPane<IdMapping>
 	}
 
 	private String[] sortedUniqueGeneratorNames() {
-		return CollectionTools.array(
-			CollectionTools.sortedSet(
-				new TransformationIterator<Generator, String>(
-						new FilteringIterator<Generator, Generator>(getSubject().getPersistenceUnit().allGenerators()) 
-						{
-							@Override
-							protected boolean accept(Generator o) {
-								return o.getName() != null;
-							}
-						})
-					{
-					@Override
-					protected String transform(Generator next) {
-						return next.getName();
-					}
-				}),
-			new String[0]);
+		return CollectionTools.sort(this.getSubject().getPersistenceUnit().uniqueGeneratorNames());
 	}
-}
\ No newline at end of file
+
+}
diff --git a/jpa/plugins/org.eclipse.jpt.ui/src/org/eclipse/jpt/ui/internal/navigator/JpaNavigatorContentProvider.java b/jpa/plugins/org.eclipse.jpt.ui/src/org/eclipse/jpt/ui/internal/navigator/JpaNavigatorContentProvider.java
index 7d88736920..f7dd114c65 100644
--- a/jpa/plugins/org.eclipse.jpt.ui/src/org/eclipse/jpt/ui/internal/navigator/JpaNavigatorContentProvider.java
+++ b/jpa/plugins/org.eclipse.jpt.ui/src/org/eclipse/jpt/ui/internal/navigator/JpaNavigatorContentProvider.java
@@ -132,7 +132,7 @@ public class JpaNavigatorContentProvider
 					JpaPlatformUi platformUi = JptUiPlugin.getPlugin().jpaPlatformUi(jpaProject.getJpaPlatform());
 					
 					if (platformUi != null) {
-						return new Object[] {jpaProject.getRootContext()};
+						return new Object[] {jpaProject.getRootContextNode()};
 					}
 				}	
 			}
diff --git a/jpa/plugins/org.eclipse.jpt.ui/src/org/eclipse/jpt/ui/internal/platform/base/EntitiesGenerator.java b/jpa/plugins/org.eclipse.jpt.ui/src/org/eclipse/jpt/ui/internal/platform/base/EntitiesGenerator.java
index f859879bb0..063d971c20 100644
--- a/jpa/plugins/org.eclipse.jpt.ui/src/org/eclipse/jpt/ui/internal/platform/base/EntitiesGenerator.java
+++ b/jpa/plugins/org.eclipse.jpt.ui/src/org/eclipse/jpt/ui/internal/platform/base/EntitiesGenerator.java
@@ -90,7 +90,7 @@ public class EntitiesGenerator {
 		
 		if (wizard.synchronizePersistenceXml()) {
 			// we currently only support *one* persistence.xml file per project
-			PersistenceXml persistenceXml = this.project.getRootContext().getPersistenceXml();
+			PersistenceXml persistenceXml = this.project.getRootContextNode().getPersistenceXml();
 			if (persistenceXml != null) {
 				// TODO casting to IFile - just trying to get rid of all compiler errors for now
 				synchClassesJob = new SynchronizeClassesJob((IFile) persistenceXml.getResource());
diff --git a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/ContextModelTestCase.java b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/ContextModelTestCase.java
index 7953e80e7d..e7245fd8f6 100644
--- a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/ContextModelTestCase.java
+++ b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/ContextModelTestCase.java
@@ -124,7 +124,7 @@ public abstract class ContextModelTestCase extends AnnotationTestCase
 	}
 	
 	protected PersistenceUnit persistenceUnit() {
-		return rootContext().getPersistenceXml().getPersistence().persistenceUnits().next();
+		return getRootContextNode().getPersistenceXml().getPersistence().persistenceUnits().next();
 	}
 	
 	protected ClassRef classRef() {
@@ -161,8 +161,8 @@ public abstract class ContextModelTestCase extends AnnotationTestCase
 		xmlPersistenceUnit.getClasses().remove(xmlJavaClassRefToRemove);
 	}
 
-	protected JpaRootContextNode rootContext() {
-		return getJavaProject().getJpaProject().getRootContext();
+	protected JpaRootContextNode getRootContextNode() {
+		return getJavaProject().getJpaProject().getRootContextNode();
 	}
 	
 	@Override
diff --git a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/JpaFileTests.java b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/JpaFileTests.java
index 1f683e4c67..d35c8e92fa 100644
--- a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/JpaFileTests.java
+++ b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/JpaFileTests.java
@@ -121,9 +121,9 @@ public class JpaFileTests extends ContextModelTestCase
 	public void testUpdatePersistenceRootStructureNodePersistenceRemoved() throws Exception {
 		IFile file = persistenceResource().getResourceModel().getFile();
 		JpaFile persistenceXmlJpaFile = JptCorePlugin.getJpaFile(file);
-		assertEquals(rootContext().getPersistenceXml().getPersistence(), persistenceXmlJpaFile.rootStructureNodes().next());
+		assertEquals(getRootContextNode().getPersistenceXml().getPersistence(), persistenceXmlJpaFile.rootStructureNodes().next());
 		
-		rootContext().getPersistenceXml().removePersistence();	
+		getRootContextNode().getPersistenceXml().removePersistence();	
 		assertFalse(persistenceXmlJpaFile.rootStructureNodes().hasNext());
 	}
 	
@@ -135,7 +135,7 @@ public class JpaFileTests extends ContextModelTestCase
 		
 		assertEquals(ormPersistentType.getJavaPersistentType(), javaJpaFile.rootStructureNodes().next());
 		
-		rootContext().getPersistenceXml().removePersistence();
+		getRootContextNode().getPersistenceXml().removePersistence();
 		assertFalse(javaJpaFile.rootStructureNodes().hasNext());
 	}
 	
@@ -147,15 +147,15 @@ public class JpaFileTests extends ContextModelTestCase
 		
 		assertEquals(javaPersistentType(), javaJpaFile.rootStructureNodes().next());
 		
-		rootContext().getPersistenceXml().removePersistence();
+		getRootContextNode().getPersistenceXml().removePersistence();
 		assertFalse(javaJpaFile.rootStructureNodes().hasNext());
 	}
 
 	public void testPersistenceRootStructureNodeRemovedFromResourceModel() throws Exception {
 		IFile file = persistenceResource().getResourceModel().getFile();
 		JpaFile persistenceXmlJpaFile = JptCorePlugin.getJpaFile(file);
-		rootContext().getPersistenceXml().getPersistence();
-		assertEquals(rootContext().getPersistenceXml().getPersistence(), persistenceXmlJpaFile.rootStructureNodes().next());
+		getRootContextNode().getPersistenceXml().getPersistence();
+		assertEquals(getRootContextNode().getPersistenceXml().getPersistence(), persistenceXmlJpaFile.rootStructureNodes().next());
 		
 		persistenceResource().getContents().remove(persistenceResource().getPersistence());
 		
@@ -165,9 +165,9 @@ public class JpaFileTests extends ContextModelTestCase
 	public void testUpdatePersistenceRootStructureNodePersistenceXmlRemoved() throws Exception {
 		IFile file = persistenceResource().getResourceModel().getFile();
 		JpaFile persistenceXmlJpaFile = JptCorePlugin.getJpaFile(file);
-		assertEquals(rootContext().getPersistenceXml().getPersistence(), persistenceXmlJpaFile.rootStructureNodes().next());
+		assertEquals(getRootContextNode().getPersistenceXml().getPersistence(), persistenceXmlJpaFile.rootStructureNodes().next());
 		
-		rootContext().removePersistenceXml();
+		getRootContextNode().removePersistenceXml();
 		assertFalse(persistenceXmlJpaFile.rootStructureNodes().hasNext());
 	}
 	
@@ -179,7 +179,7 @@ public class JpaFileTests extends ContextModelTestCase
 		
 		assertEquals(ormPersistentType.getJavaPersistentType(), javaJpaFile.rootStructureNodes().next());
 		
-		rootContext().removePersistenceXml();
+		getRootContextNode().removePersistenceXml();
 		assertFalse(javaJpaFile.rootStructureNodes().hasNext());
 	}
 	
@@ -191,7 +191,7 @@ public class JpaFileTests extends ContextModelTestCase
 		
 		assertEquals(javaPersistentType(), javaJpaFile.rootStructureNodes().next());
 		
-		rootContext().removePersistenceXml();
+		getRootContextNode().removePersistenceXml();
 		assertFalse(javaJpaFile.rootStructureNodes().hasNext());
 	}
 	
@@ -312,7 +312,7 @@ public class JpaFileTests extends ContextModelTestCase
 		JavaPersistentType javaPersistentType = ormPersistentType.getJavaPersistentType();
 		assertEquals(javaPersistentType, javaJpaFile.rootStructureNodes().next());
 		
-		jpaProject().getRootContext().getPersistenceXml().getPersistence().removePersistenceUnit(0);
+		jpaProject().getRootContextNode().getPersistenceXml().getPersistence().removePersistenceUnit(0);
 
 		assertFalse(javaJpaFile.rootStructureNodes().hasNext());
 		assertEquals(0, javaJpaFile.rootStructureNodesSize());
diff --git a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/orm/OrmJoinTableTests.java b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/orm/OrmJoinTableTests.java
index 09533a9785..b4a1da69d8 100644
--- a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/orm/OrmJoinTableTests.java
+++ b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/orm/OrmJoinTableTests.java
@@ -37,6 +37,7 @@ import org.eclipse.jpt.core.tests.internal.context.ContextModelTestCase;
 import org.eclipse.jpt.core.tests.internal.projects.TestJavaProject.SourceWriter;
 import org.eclipse.jpt.utility.internal.iterators.ArrayIterator;
 
+@SuppressWarnings("nls")
 public class OrmJoinTableTests extends ContextModelTestCase
 {
 	public OrmJoinTableTests(String name) {
diff --git a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/orm/OrmXmlTests.java b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/orm/OrmXmlTests.java
index c210d14c5d..1e7947c8b0 100644
--- a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/orm/OrmXmlTests.java
+++ b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/orm/OrmXmlTests.java
@@ -36,7 +36,7 @@ public class OrmXmlTests extends ContextModelTestCase
 	}
 	
 	protected PersistenceXml persistenceXml() {
-		return rootContext().getPersistenceXml();
+		return getRootContextNode().getPersistenceXml();
 	}
 	
 	protected OrmXml ormXml() {
diff --git a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/persistence/JptCorePersistenceContextModelTests.java b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/persistence/JptCorePersistenceContextModelTests.java
index 5dd87d2a34..71707d99c2 100644
--- a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/persistence/JptCorePersistenceContextModelTests.java
+++ b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/persistence/JptCorePersistenceContextModelTests.java
@@ -22,7 +22,7 @@ public class JptCorePersistenceContextModelTests extends TestCase
 	
 	public static Test suite(boolean all) {
 		TestSuite suite = new TestSuite(JptCorePersistenceContextModelTests.class.getName());
-		suite.addTestSuite(RootContextTests.class);
+		suite.addTestSuite(RootContextNodeTests.class);
 		suite.addTestSuite(PersistenceXmlTests.class);
 		suite.addTestSuite(PersistenceTests.class);
 		suite.addTestSuite(PersistenceUnitTests.class);
diff --git a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/persistence/PersistenceTests.java b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/persistence/PersistenceTests.java
index 4dc384a858..9c76269325 100644
--- a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/persistence/PersistenceTests.java
+++ b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/persistence/PersistenceTests.java
@@ -24,13 +24,13 @@ public class PersistenceTests extends ContextModelTestCase
 	}
 	
 	protected Persistence persistence() {
-		return rootContext().getPersistenceXml().getPersistence();
+		return getRootContextNode().getPersistenceXml().getPersistence();
 	}
 	
 	public void testUpdateAddPersistenceUnit() throws Exception {
 		PersistenceResource prm = persistenceResource();
 		XmlPersistence xmlPersistence = prm.getPersistence();
-		Persistence persistence = rootContext().getPersistenceXml().getPersistence();
+		Persistence persistence = getRootContextNode().getPersistenceXml().getPersistence();
 		
 		// clear xml persistence units, test that it's clear in context
 		xmlPersistence.getPersistenceUnits().clear();
@@ -80,7 +80,7 @@ public class PersistenceTests extends ContextModelTestCase
 	public void testUpdateRemovePersistenceUnit() throws Exception {
 		PersistenceResource prm = persistenceResource();
 		XmlPersistence xmlPersistence = prm.getPersistence();
-		Persistence persistence = rootContext().getPersistenceXml().getPersistence();
+		Persistence persistence = getRootContextNode().getPersistenceXml().getPersistence();
 		
 		// add a persistence unit and test that there are two existing xml and 
 		// one context persistence unit
diff --git a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/persistence/PersistenceXmlTests.java b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/persistence/PersistenceXmlTests.java
index 343f7f2ca6..5e7c816754 100644
--- a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/persistence/PersistenceXmlTests.java
+++ b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/persistence/PersistenceXmlTests.java
@@ -22,7 +22,7 @@ public class PersistenceXmlTests extends ContextModelTestCase
 	}
 	
 	protected PersistenceXml persistenceXml() {
-		return rootContext().getPersistenceXml();
+		return getRootContextNode().getPersistenceXml();
 	}
 	
 	public void testUpdateAddPersistence() throws Exception {
diff --git a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/persistence/RootContextTests.java b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/persistence/RootContextNodeTests.java
index 6e719084f2..6cf8b7ecd2 100644
--- a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/persistence/RootContextTests.java
+++ b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/context/persistence/RootContextNodeTests.java
@@ -15,9 +15,9 @@ import org.eclipse.jpt.core.resource.persistence.PersistenceFactory;
 import org.eclipse.jpt.core.resource.persistence.PersistenceResource;
 import org.eclipse.jpt.core.tests.internal.context.ContextModelTestCase;
 
-public class RootContextTests extends ContextModelTestCase
+public class RootContextNodeTests extends ContextModelTestCase
 {
-	public RootContextTests(String name) {
+	public RootContextNodeTests(String name) {
 		super(name);
 	}
 	
@@ -27,7 +27,7 @@ public class RootContextTests extends ContextModelTestCase
 		
 		assertFalse(pr.exists());
 		
-		JpaRootContextNode baseJpaContent = getJavaProject().getJpaProject().getRootContext();
+		JpaRootContextNode baseJpaContent = getJavaProject().getJpaProject().getRootContextNode();
 		assertNull(baseJpaContent.getPersistenceXml());
 		
 		baseJpaContent.addPersistenceXml();
@@ -46,7 +46,7 @@ public class RootContextTests extends ContextModelTestCase
 	}
 	
 	public void testModifyRemovePersistenceXml() throws Exception {
-		JpaRootContextNode baseJpaContent = getJavaProject().getJpaProject().getRootContext();
+		JpaRootContextNode baseJpaContent = getJavaProject().getJpaProject().getRootContextNode();
 		
 		assertNotNull(baseJpaContent.getPersistenceXml());
 		
@@ -72,7 +72,7 @@ public class RootContextTests extends ContextModelTestCase
 		
 		assertFalse(pr.exists());
 		
-		JpaRootContextNode baseJpaContent = getJavaProject().getJpaProject().getRootContext();
+		JpaRootContextNode baseJpaContent = getJavaProject().getJpaProject().getRootContextNode();
 		assertNull(baseJpaContent.getPersistenceXml());
 		
 		pr.getContents().add(PersistenceFactory.eINSTANCE.createXmlPersistence());
@@ -82,7 +82,7 @@ public class RootContextTests extends ContextModelTestCase
 	
 	public void testUpdateRemovePersistenceXml() throws Exception {
 		PersistenceResource pr = persistenceResource();
-		JpaRootContextNode baseJpaContent = getJavaProject().getJpaProject().getRootContext();
+		JpaRootContextNode baseJpaContent = getJavaProject().getJpaProject().getRootContextNode();
 		
 		assertNotNull(baseJpaContent.getPersistenceXml());