Attachment #211360 for bug #325162

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




import org.eclipse.jpt.common.core.utility.TextRange;
import org.eclipse.jpt.common.utility.Filter;
import org.eclipse.jpt.common.utility.internal.Association;
import org.eclipse.jpt.common.utility.internal.CollectionTools;
import org.eclipse.jpt.common.utility.internal.SimpleAssociation;
import org.eclipse.jpt.common.utility.internal.StringTools;
import org.eclipse.jpt.common.utility.internal.Tools;

import org.eclipse.jpt.common.utility.internal.iterables.SubListIterableWrapper;
import org.eclipse.jpt.common.utility.internal.iterables.TransformationIterable;
import org.eclipse.jpt.jpa.core.JpaFactory;
import org.eclipse.jpt.jpa.core.MappingKeys;
import org.eclipse.jpt.jpa.core.context.AssociationOverride;
import org.eclipse.jpt.jpa.core.context.AssociationOverrideContainer;
import org.eclipse.jpt.jpa.core.context.AttributeMapping;
import org.eclipse.jpt.jpa.core.context.AttributeOverride;
import org.eclipse.jpt.jpa.core.context.AttributeOverrideContainer;
import org.eclipse.jpt.jpa.core.context.BaseEmbeddedMapping;
import org.eclipse.jpt.jpa.core.context.Column;
import org.eclipse.jpt.jpa.core.context.Converter;
import org.eclipse.jpt.jpa.core.context.Embeddable;

import org.eclipse.jpt.jpa.core.context.ReadOnlyOverride;
import org.eclipse.jpt.jpa.core.context.ReadOnlyTable;
import org.eclipse.jpt.jpa.core.context.Relationship;
import org.eclipse.jpt.jpa.core.context.RelationshipMapping;
import org.eclipse.jpt.jpa.core.context.Table;
import org.eclipse.jpt.jpa.core.context.TypeMapping;
import org.eclipse.jpt.jpa.core.context.java.JavaAssociationOverrideContainer;

import org.eclipse.jpt.jpa.core.jpa2.JpaFactory2_0;
import org.eclipse.jpt.jpa.core.jpa2.MappingKeys2_0;
import org.eclipse.jpt.jpa.core.jpa2.context.CollectionTable2_0;
import org.eclipse.jpt.jpa.core.jpa2.context.ManyToOneRelationship2_0;
import org.eclipse.jpt.jpa.core.jpa2.context.MetamodelField;
import org.eclipse.jpt.jpa.core.jpa2.context.Orderable2_0;
import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaAssociationOverrideContainer2_0;

		this.collectionTable.validate(messages, reporter, astRoot);
		this.validateValue(messages, reporter, astRoot);
		this.validateMapKey(messages, reporter, astRoot);
		this.validateNoEmbeddableInMappingContainsProhibittedMapping(messages, astRoot);
	}

	protected void validateNoEmbeddableInMappingContainsProhibittedMapping(List<IMessage> messages, CompilationUnit astRoot) {
		Embeddable embeddableClass = getResolvedTargetEmbeddable();
		if (embeddableClass != null) {
			embeddableContainsElementCollection(messages, astRoot, embeddableClass);
			embeddableContainsProhibitedRelationshipMapping(messages, astRoot, embeddableClass);
			embeddableHierarchyContainsProhibittedMapping(messages, astRoot, embeddableClass, new ArrayList<Embeddable>());
		}
		embeddableClass = getResolvedMapKeyEmbeddable();
		if (embeddableClass != null) {
			embeddableContainsElementCollection(messages, astRoot, embeddableClass);
			embeddableContainsProhibitedRelationshipMapping(messages, astRoot, embeddableClass);
			embeddableHierarchyContainsProhibittedMapping(messages, astRoot, embeddableClass, new ArrayList<Embeddable>());
		}
	}

	private void embeddableHierarchyContainsProhibittedMapping(List<IMessage> messages, CompilationUnit astRoot, Embeddable parentEmbeddable, List<Embeddable> visited) {
		Iterable<AttributeMapping> embeddedIterable = parentEmbeddable.getAllAttributeMappings(MappingKeys.EMBEDDED_ATTRIBUTE_MAPPING_KEY);
		for(AttributeMapping mapping : embeddedIterable) {
			Embeddable embeddable = ((BaseEmbeddedMapping)mapping).getTargetEmbeddable();
			if (embeddable != null && embeddable != parentEmbeddable) {
				embeddableContainsElementCollection(messages, astRoot, embeddable);
				embeddableContainsProhibitedRelationshipMapping(messages, astRoot, embeddable);
				if (!CollectionTools.contains(visited, embeddable)) {
					visited.add(embeddable);
					embeddableHierarchyContainsProhibittedMapping(messages, astRoot, embeddable, visited);
				}
			}
		}
		Iterable<AttributeMapping> embeddedIdIterable = parentEmbeddable.getAllAttributeMappings(MappingKeys.EMBEDDED_ID_ATTRIBUTE_MAPPING_KEY);
		for(AttributeMapping mapping : embeddedIdIterable) {
			Embeddable embeddable = ((BaseEmbeddedMapping)mapping).getTargetEmbeddable();
			if (embeddable != null && embeddable != parentEmbeddable) {
				embeddableContainsElementCollection(messages, astRoot, embeddable);
				embeddableContainsProhibitedRelationshipMapping(messages, astRoot, embeddable);
				if (!CollectionTools.contains(visited, embeddable)) {
					visited.add(embeddable);
					embeddableHierarchyContainsProhibittedMapping(messages, astRoot, embeddable, visited);
				}
			}
		}
	}

	private void embeddableContainsProhibitedRelationshipMapping(List<IMessage> messages, CompilationUnit astRoot, Embeddable embeddable) {
		boolean prohibitedMappingFound = false;
		RelationshipMapping relationshipMapping = null; 
		Iterable<AttributeMapping> manyToManyMappings = embeddable.getAllAttributeMappings(MappingKeys.MANY_TO_MANY_ATTRIBUTE_MAPPING_KEY);
		Iterable<AttributeMapping> oneToManyMappings = embeddable.getAllAttributeMappings(MappingKeys.ONE_TO_MANY_ATTRIBUTE_MAPPING_KEY);
		if (oneToManyMappings.iterator().hasNext()) {
			relationshipMapping = (RelationshipMapping)oneToManyMappings.iterator().next();
			prohibitedMappingFound = true;
		}
		if (manyToManyMappings.iterator().hasNext()) {
			relationshipMapping = (RelationshipMapping)manyToManyMappings.iterator().next();
			prohibitedMappingFound = true;
		}
		Iterable<AttributeMapping> manyToOneMappings = embeddable.getAllAttributeMappings(MappingKeys.MANY_TO_ONE_ATTRIBUTE_MAPPING_KEY);
		if (manyToOneMappings.iterator().hasNext()) {
			relationshipMapping = (RelationshipMapping)manyToOneMappings.iterator().next();
			if (((RelationshipMapping)manyToOneMappings.iterator().next()).getRelationshipOwner() != null
					|| ((ManyToOneRelationship2_0)relationshipMapping.getRelationship()).getJoinTableStrategy().getJoinTable() != null) {
				prohibitedMappingFound = true;
			}
		}
		Iterable<AttributeMapping> oneToOneMappings = embeddable.getAllAttributeMappings(MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY);
		if (oneToOneMappings.iterator().hasNext()) {
			relationshipMapping = (RelationshipMapping)oneToOneMappings.iterator().next();
			if (relationshipMapping.getRelationshipOwner() != null) {
				prohibitedMappingFound = true;
			}
		}
		if (prohibitedMappingFound) {
			if (getPersistentAttribute().isVirtual()) {
				messages.add(
						DefaultJpaValidationMessages.buildMessage(
								IMessage.HIGH_SEVERITY,
								JpaValidationMessages.VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_PROHIBITED_RELATIONSHIP_MAPPING,
								new String[] {this.getName(), 
										embeddable.getName(), relationshipMapping.getName()},
								this,
								this.getValidationTextRange(astRoot)
						)
				);				
			} else {
			messages.add(
					DefaultJpaValidationMessages.buildMessage(
							IMessage.HIGH_SEVERITY,
							JpaValidationMessages.ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_PROHIBITED_RELATIONSHIP_MAPPING,
							new String[] {embeddable.getName(), relationshipMapping.getName()},
							this,
							this.getValidationTextRange(astRoot)
					)
			);
			}
		}
	}

	private void embeddableContainsElementCollection(List<IMessage> messages, CompilationUnit astRoot, Embeddable embeddable) {
		Iterable<AttributeMapping> elementCollectionMappings = embeddable.getAllAttributeMappings(MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
		if (elementCollectionMappings.iterator().hasNext()) {
			if (getPersistentAttribute().isVirtual()) {
				messages.add(
						DefaultJpaValidationMessages.buildMessage(
								IMessage.HIGH_SEVERITY,
								JpaValidationMessages.VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_ELEMENT_COLLECTION_MAPPING,
								new String[] {this.getName(), embeddable.getName(), elementCollectionMappings.iterator().next().getName()},
								this,
								this.getValidationTextRange(astRoot)
						)
				);				
			} else {
				messages.add(
						DefaultJpaValidationMessages.buildMessage(
								IMessage.HIGH_SEVERITY,
								JpaValidationMessages.ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_ELEMENT_COLLECTION_MAPPING,
								new String[] {embeddable.getName(), elementCollectionMappings.iterator().next().getName()},
								this,
								this.getValidationTextRange(astRoot)
						)
				);
			}
		}
	}

	protected void validateTargetClass(List<IMessage> messages, CompilationUnit astRoot) {




import org.eclipse.jdt.core.IType;
import org.eclipse.jpt.common.core.internal.utility.JDTTools;
import org.eclipse.jpt.common.core.utility.TextRange;
import org.eclipse.jpt.common.utility.internal.CollectionTools;
import org.eclipse.jpt.common.utility.internal.StringTools;
import org.eclipse.jpt.common.utility.internal.Tools;
import org.eclipse.jpt.common.utility.internal.Transformer;

import org.eclipse.jpt.common.utility.internal.iterables.SingleElementIterable;
import org.eclipse.jpt.common.utility.internal.iterables.SingleElementListIterable;
import org.eclipse.jpt.common.utility.internal.iterables.TransformationIterable;
import org.eclipse.jpt.jpa.core.MappingKeys;
import org.eclipse.jpt.jpa.core.context.AssociationOverride;
import org.eclipse.jpt.jpa.core.context.AssociationOverrideContainer;
import org.eclipse.jpt.jpa.core.context.AttributeMapping;
import org.eclipse.jpt.jpa.core.context.AttributeOverride;
import org.eclipse.jpt.jpa.core.context.AttributeOverrideContainer;
import org.eclipse.jpt.jpa.core.context.BaseEmbeddedMapping;
import org.eclipse.jpt.jpa.core.context.Column;
import org.eclipse.jpt.jpa.core.context.Converter;
import org.eclipse.jpt.jpa.core.context.Embeddable;

import org.eclipse.jpt.jpa.core.context.ReadOnlyOverride;
import org.eclipse.jpt.jpa.core.context.ReadOnlyTable;
import org.eclipse.jpt.jpa.core.context.Relationship;
import org.eclipse.jpt.jpa.core.context.RelationshipMapping;
import org.eclipse.jpt.jpa.core.context.Table;
import org.eclipse.jpt.jpa.core.context.TypeMapping;
import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute;

import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
import org.eclipse.jpt.jpa.core.jpa2.MappingKeys2_0;
import org.eclipse.jpt.jpa.core.jpa2.context.CollectionTable2_0;
import org.eclipse.jpt.jpa.core.jpa2.context.ManyToOneRelationship2_0;
import org.eclipse.jpt.jpa.core.jpa2.context.MetamodelField;
import org.eclipse.jpt.jpa.core.jpa2.context.Orderable2_0;
import org.eclipse.jpt.jpa.core.jpa2.context.orm.OrmAssociationOverrideContainer2_0;

		this.collectionTable.validate(messages, reporter);
		this.validateValue(messages, reporter);
		this.validateMapKey(messages, reporter);
		this.validateNoEmbeddableInMappingContainsProhibittedMapping(messages);
	}

	protected void validateNoEmbeddableInMappingContainsProhibittedMapping(List<IMessage> messages) {
			Embeddable embeddableClass = getResolvedTargetEmbeddable();
			if (embeddableClass != null) {
				embeddableContainsElementCollection(messages, embeddableClass);
				embeddableContainsProhibitedRelationshipMapping(messages, embeddableClass);
				embeddableHierarchyContainsProhibittedMapping(messages, embeddableClass, new ArrayList<Embeddable>());
			}
			embeddableClass = getResolvedMapKeyEmbeddable();
			if (embeddableClass != null) {
				embeddableContainsElementCollection(messages, embeddableClass);
				embeddableContainsProhibitedRelationshipMapping(messages, embeddableClass);
				embeddableHierarchyContainsProhibittedMapping(messages, embeddableClass, new ArrayList<Embeddable>());
			}
		}
	
		private void embeddableHierarchyContainsProhibittedMapping(List<IMessage> messages, Embeddable parentEmbeddable, List<Embeddable> visited) {
			Iterable<AttributeMapping> embeddedIterable = parentEmbeddable.getAllAttributeMappings(MappingKeys.EMBEDDED_ATTRIBUTE_MAPPING_KEY);
			for(AttributeMapping mapping : embeddedIterable) {
				Embeddable embeddable = ((BaseEmbeddedMapping)mapping).getTargetEmbeddable();
				if (embeddable != null && embeddable != parentEmbeddable) {
					embeddableContainsElementCollection(messages, embeddable);
					embeddableContainsProhibitedRelationshipMapping(messages, embeddable);
					if (!CollectionTools.contains(visited, embeddable)) {
						visited.add(embeddable);
						embeddableHierarchyContainsProhibittedMapping(messages, embeddable, visited);
					}
				}
			}
			Iterable<AttributeMapping> embeddedIdIterable = parentEmbeddable.getAllAttributeMappings(MappingKeys.EMBEDDED_ID_ATTRIBUTE_MAPPING_KEY);
			for(AttributeMapping mapping : embeddedIdIterable) {
				Embeddable embeddable = ((BaseEmbeddedMapping)mapping).getTargetEmbeddable();
				if (embeddable != null && embeddable != parentEmbeddable) {
					embeddableContainsElementCollection(messages, embeddable);
					embeddableContainsProhibitedRelationshipMapping(messages, embeddable);
					if (!CollectionTools.contains(visited, embeddable)) {
						visited.add(embeddable);
						embeddableHierarchyContainsProhibittedMapping(messages, embeddable, visited);
					}
				}
			}
		}
	
		private void embeddableContainsProhibitedRelationshipMapping(List<IMessage> messages, Embeddable embeddable) {
			boolean prohibitedMappingFound = false;
			RelationshipMapping relationshipMapping = null; 
			Iterable<AttributeMapping> manyToManyMappings = embeddable.getAllAttributeMappings(MappingKeys.MANY_TO_MANY_ATTRIBUTE_MAPPING_KEY);
			Iterable<AttributeMapping> oneToManyMappings = embeddable.getAllAttributeMappings(MappingKeys.ONE_TO_MANY_ATTRIBUTE_MAPPING_KEY);
			if (oneToManyMappings.iterator().hasNext()) {
				relationshipMapping = (RelationshipMapping)oneToManyMappings.iterator().next();
				prohibitedMappingFound = true;
			}
			if (manyToManyMappings.iterator().hasNext()) {
				relationshipMapping = (RelationshipMapping)manyToManyMappings.iterator().next();
				prohibitedMappingFound = true;
			}
			Iterable<AttributeMapping> manyToOneMappings = embeddable.getAllAttributeMappings(MappingKeys.MANY_TO_ONE_ATTRIBUTE_MAPPING_KEY);
			if (manyToOneMappings.iterator().hasNext()) {
				relationshipMapping = (RelationshipMapping)manyToOneMappings.iterator().next();
				if (((RelationshipMapping)manyToOneMappings.iterator().next()).getRelationshipOwner() != null 
						||((ManyToOneRelationship2_0)relationshipMapping.getRelationship()).getJoinTableStrategy().getJoinTable() != null) {
					prohibitedMappingFound = true;
				}
			}
			Iterable<AttributeMapping> oneToOneMappings = embeddable.getAllAttributeMappings(MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY);
			if (oneToOneMappings.iterator().hasNext()) {
				relationshipMapping = (RelationshipMapping)oneToOneMappings.iterator().next();
				if (((RelationshipMapping)oneToOneMappings.iterator().next()).getRelationshipOwner() != null) {
					prohibitedMappingFound = true;
				}
			}
			if (prohibitedMappingFound) {
				messages.add(
					DefaultJpaValidationMessages.buildMessage(
						IMessage.HIGH_SEVERITY,
						JpaValidationMessages.ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_PROHIBITED_RELATIONSHIP_MAPPING,
						new String[] {embeddable.getName(), relationshipMapping.getName()},
						this,
						this.getValidationTextRange()
					)
				);
			}
		}
		
		private void embeddableContainsElementCollection(List<IMessage> messages, Embeddable embeddable) {
			Iterable<AttributeMapping> elementCollectionMappings = embeddable.getAllAttributeMappings(MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
			if (elementCollectionMappings.iterator().hasNext()) {
				messages.add(
					DefaultJpaValidationMessages.buildMessage(
						IMessage.HIGH_SEVERITY,
						JpaValidationMessages.ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_ELEMENT_COLLECTION_MAPPING,
						new String[] {embeddable.getName(), elementCollectionMappings.iterator().next().getName()},
						this,
						this.getValidationTextRange()
					)
				);							
			}
	 	}
		
		protected void validateTargetClass(List<IMessage> messages) {
		if (StringTools.stringIsEmpty(this.getTargetClass())) {
			messages.add(
				DefaultJpaValidationMessages.buildMessage(

Return to bug 325162

Lines 91-96 Link Here

(-)property_files/jpa_validation.properties (+4 lines)
91	ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST=Target class \"{0}\" does not exist	91	ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST=Target class \"{0}\" does not exist
92	ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE=Target class \"{0}\" is not an embeddable or basic type	92	ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE=Target class \"{0}\" is not an embeddable or basic type
93	ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED=Target class is not defined	93	ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED=Target class is not defined
		94	ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_ELEMENT_COLLECTION_MAPPING=Mapping contains an embeddable \"{0}\" with a prohibited mapping \"{1}\", element collections may not contain embeddables with element collection mappings
		95	ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_PROHIBITED_RELATIONSHIP_MAPPING=Mapping contains an embeddable \"{0}\" with a prohibited mapping \"{1}\", embeddables in element collections may only contain many-to-one or one-to-one mappings which must be on the \"owning\" side of the relationship and must not use join table
94	EMBEDDED_ID_MAPPING_MAPPED_BY_RELATIONSHIP_AND_ATTRIBUTE_OVERRIDES_SPECIFIED=Embedded IDs that are mapped by a relationship should not specify any attribute overrides.	96	EMBEDDED_ID_MAPPING_MAPPED_BY_RELATIONSHIP_AND_ATTRIBUTE_OVERRIDES_SPECIFIED=Embedded IDs that are mapped by a relationship should not specify any attribute overrides.
95	ID_MAPPING_MAPPED_BY_RELATIONSHIP_AND_COLUMN_SPECIFIED=In {0}, a column is specified, but it is mapped by a relationship. IDs that are mapped by a relationship should not specify a column.	97	ID_MAPPING_MAPPED_BY_RELATIONSHIP_AND_COLUMN_SPECIFIED=In {0}, a column is specified, but it is mapped by a relationship. IDs that are mapped by a relationship should not specify a column.
96	MAPS_ID_VALUE_INVALID=In {0}, the "maps ID" value ''{1}'' does not refer to an attribute that is used as an ID for this entity	98	MAPS_ID_VALUE_INVALID=In {0}, the "maps ID" value ''{1}'' does not refer to an attribute that is used as an ID for this entity
Lines 117-122 Link Here
117	TARGET_ENTITY_NOT_EXIST=Target entity \"{0}\" does not exist	119	TARGET_ENTITY_NOT_EXIST=Target entity \"{0}\" does not exist
118	VIRTUAL_ATTRIBUTE_MAP_KEY_CLASS_NOT_DEFINED=In implied attribute \"{0}\", map key class is not defined	120	VIRTUAL_ATTRIBUTE_MAP_KEY_CLASS_NOT_DEFINED=In implied attribute \"{0}\", map key class is not defined
119	VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST="In implied attribute \"{0}\", target class does not exist on the classpath"	121	VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST="In implied attribute \"{0}\", target class does not exist on the classpath"
		122	VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_ELEMENT_COLLECTION_MAPPING=In implied attribute \"{0}"\, mapping contains an embeddable \"{1}\" with a prohibited mapping \"{2}\", element collections may not contain embeddables with element collection mappings
		123	VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_PROHIBITED_RELATIONSHIP_MAPPING=In implied attribute \"{0}"\, mapping contains an embeddable \"{1}\" with a prohibited mapping \"{2}\", embeddables in element collections may only contain many-to-one or one-to-one mappings which must be on the \"owning\" side of the relationship and not use a join table
120	VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE=In implied attribute \"{0}\", target class \"{1}\" is not an embeddable or basic type	124	VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE=In implied attribute \"{0}\", target class \"{1}\" is not an embeddable or basic type
121	VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED=In implied attribute \"{0}\", target class is not defined	125	VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED=In implied attribute \"{0}\", target class is not defined
122	VIRTUAL_ATTRIBUTE_TARGET_ENTITY_IS_NOT_AN_ENTITY=In implied attribute \"{0}\", target entity \"{1}\" is not an Entity	126	VIRTUAL_ATTRIBUTE_TARGET_ENTITY_IS_NOT_AN_ENTITY=In implied attribute \"{0}\", target entity \"{1}\" is not an Entity

Lines 20-25 Link Here

(-)src/org/eclipse/jpt/jpa/core/internal/jpa2/context/java/AbstractJavaElementCollectionMapping2_0.java (+129 lines)
20	import org.eclipse.jpt.common.core.utility.TextRange;	20	import org.eclipse.jpt.common.core.utility.TextRange;
21	import org.eclipse.jpt.common.utility.Filter;	21	import org.eclipse.jpt.common.utility.Filter;
22	import org.eclipse.jpt.common.utility.internal.Association;	22	import org.eclipse.jpt.common.utility.internal.Association;
		23	import org.eclipse.jpt.common.utility.internal.CollectionTools;
23	import org.eclipse.jpt.common.utility.internal.SimpleAssociation;	24	import org.eclipse.jpt.common.utility.internal.SimpleAssociation;
24	import org.eclipse.jpt.common.utility.internal.StringTools;	25	import org.eclipse.jpt.common.utility.internal.StringTools;
25	import org.eclipse.jpt.common.utility.internal.Tools;	26	import org.eclipse.jpt.common.utility.internal.Tools;
Lines 34-44 Link Here
34	import org.eclipse.jpt.common.utility.internal.iterables.SubListIterableWrapper;	35	import org.eclipse.jpt.common.utility.internal.iterables.SubListIterableWrapper;
35	import org.eclipse.jpt.common.utility.internal.iterables.TransformationIterable;	36	import org.eclipse.jpt.common.utility.internal.iterables.TransformationIterable;
36	import org.eclipse.jpt.jpa.core.JpaFactory;	37	import org.eclipse.jpt.jpa.core.JpaFactory;
		38	import org.eclipse.jpt.jpa.core.MappingKeys;
37	import org.eclipse.jpt.jpa.core.context.AssociationOverride;	39	import org.eclipse.jpt.jpa.core.context.AssociationOverride;
38	import org.eclipse.jpt.jpa.core.context.AssociationOverrideContainer;	40	import org.eclipse.jpt.jpa.core.context.AssociationOverrideContainer;
39	import org.eclipse.jpt.jpa.core.context.AttributeMapping;	41	import org.eclipse.jpt.jpa.core.context.AttributeMapping;
40	import org.eclipse.jpt.jpa.core.context.AttributeOverride;	42	import org.eclipse.jpt.jpa.core.context.AttributeOverride;
41	import org.eclipse.jpt.jpa.core.context.AttributeOverrideContainer;	43	import org.eclipse.jpt.jpa.core.context.AttributeOverrideContainer;
		44	import org.eclipse.jpt.jpa.core.context.BaseEmbeddedMapping;
42	import org.eclipse.jpt.jpa.core.context.Column;	45	import org.eclipse.jpt.jpa.core.context.Column;
43	import org.eclipse.jpt.jpa.core.context.Converter;	46	import org.eclipse.jpt.jpa.core.context.Converter;
44	import org.eclipse.jpt.jpa.core.context.Embeddable;	47	import org.eclipse.jpt.jpa.core.context.Embeddable;
Lines 56-61 Link Here
56	import org.eclipse.jpt.jpa.core.context.ReadOnlyOverride;	59	import org.eclipse.jpt.jpa.core.context.ReadOnlyOverride;
57	import org.eclipse.jpt.jpa.core.context.ReadOnlyTable;	60	import org.eclipse.jpt.jpa.core.context.ReadOnlyTable;
58	import org.eclipse.jpt.jpa.core.context.Relationship;	61	import org.eclipse.jpt.jpa.core.context.Relationship;
		62	import org.eclipse.jpt.jpa.core.context.RelationshipMapping;
59	import org.eclipse.jpt.jpa.core.context.Table;	63	import org.eclipse.jpt.jpa.core.context.Table;
60	import org.eclipse.jpt.jpa.core.context.TypeMapping;	64	import org.eclipse.jpt.jpa.core.context.TypeMapping;
61	import org.eclipse.jpt.jpa.core.context.java.JavaAssociationOverrideContainer;	65	import org.eclipse.jpt.jpa.core.context.java.JavaAssociationOverrideContainer;
Lines 96-101 Link Here
96	import org.eclipse.jpt.jpa.core.jpa2.JpaFactory2_0;	100	import org.eclipse.jpt.jpa.core.jpa2.JpaFactory2_0;
97	import org.eclipse.jpt.jpa.core.jpa2.MappingKeys2_0;	101	import org.eclipse.jpt.jpa.core.jpa2.MappingKeys2_0;
98	import org.eclipse.jpt.jpa.core.jpa2.context.CollectionTable2_0;	102	import org.eclipse.jpt.jpa.core.jpa2.context.CollectionTable2_0;
		103	import org.eclipse.jpt.jpa.core.jpa2.context.ManyToOneRelationship2_0;
99	import org.eclipse.jpt.jpa.core.jpa2.context.MetamodelField;	104	import org.eclipse.jpt.jpa.core.jpa2.context.MetamodelField;
100	import org.eclipse.jpt.jpa.core.jpa2.context.Orderable2_0;	105	import org.eclipse.jpt.jpa.core.jpa2.context.Orderable2_0;
101	import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaAssociationOverrideContainer2_0;	106	import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaAssociationOverrideContainer2_0;
Lines 1474-1479 Link Here
1474	this.collectionTable.validate(messages, reporter, astRoot);	1479	this.collectionTable.validate(messages, reporter, astRoot);
1475	this.validateValue(messages, reporter, astRoot);	1480	this.validateValue(messages, reporter, astRoot);
1476	this.validateMapKey(messages, reporter, astRoot);	1481	this.validateMapKey(messages, reporter, astRoot);
		1482	this.validateNoEmbeddableInMappingContainsProhibittedMapping(messages, astRoot);
		1483	}
		1484
		1485	protected void validateNoEmbeddableInMappingContainsProhibittedMapping(List<IMessage> messages, CompilationUnit astRoot) {
		1486	Embeddable embeddableClass = getResolvedTargetEmbeddable();
		1487	if (embeddableClass != null) {
		1488	embeddableContainsElementCollection(messages, astRoot, embeddableClass);
		1489	embeddableContainsProhibitedRelationshipMapping(messages, astRoot, embeddableClass);
		1490	embeddableHierarchyContainsProhibittedMapping(messages, astRoot, embeddableClass, new ArrayList<Embeddable>());
		1491	}
		1492	embeddableClass = getResolvedMapKeyEmbeddable();
		1493	if (embeddableClass != null) {
		1494	embeddableContainsElementCollection(messages, astRoot, embeddableClass);
		1495	embeddableContainsProhibitedRelationshipMapping(messages, astRoot, embeddableClass);
		1496	embeddableHierarchyContainsProhibittedMapping(messages, astRoot, embeddableClass, new ArrayList<Embeddable>());
		1497	}
		1498	}
		1499
		1500	private void embeddableHierarchyContainsProhibittedMapping(List<IMessage> messages, CompilationUnit astRoot, Embeddable parentEmbeddable, List<Embeddable> visited) {
		1501	Iterable<AttributeMapping> embeddedIterable = parentEmbeddable.getAllAttributeMappings(MappingKeys.EMBEDDED_ATTRIBUTE_MAPPING_KEY);
		1502	for(AttributeMapping mapping : embeddedIterable) {
		1503	Embeddable embeddable = ((BaseEmbeddedMapping)mapping).getTargetEmbeddable();
		1504	if (embeddable != null && embeddable != parentEmbeddable) {
		1505	embeddableContainsElementCollection(messages, astRoot, embeddable);
		1506	embeddableContainsProhibitedRelationshipMapping(messages, astRoot, embeddable);
		1507	if (!CollectionTools.contains(visited, embeddable)) {
		1508	visited.add(embeddable);
		1509	embeddableHierarchyContainsProhibittedMapping(messages, astRoot, embeddable, visited);
		1510	}
		1511	}
		1512	}
		1513	Iterable<AttributeMapping> embeddedIdIterable = parentEmbeddable.getAllAttributeMappings(MappingKeys.EMBEDDED_ID_ATTRIBUTE_MAPPING_KEY);
		1514	for(AttributeMapping mapping : embeddedIdIterable) {
		1515	Embeddable embeddable = ((BaseEmbeddedMapping)mapping).getTargetEmbeddable();
		1516	if (embeddable != null && embeddable != parentEmbeddable) {
		1517	embeddableContainsElementCollection(messages, astRoot, embeddable);
		1518	embeddableContainsProhibitedRelationshipMapping(messages, astRoot, embeddable);
		1519	if (!CollectionTools.contains(visited, embeddable)) {
		1520	visited.add(embeddable);
		1521	embeddableHierarchyContainsProhibittedMapping(messages, astRoot, embeddable, visited);
		1522	}
		1523	}
		1524	}
		1525	}
		1526
		1527	private void embeddableContainsProhibitedRelationshipMapping(List<IMessage> messages, CompilationUnit astRoot, Embeddable embeddable) {
		1528	boolean prohibitedMappingFound = false;
		1529	RelationshipMapping relationshipMapping = null;
		1530	Iterable<AttributeMapping> manyToManyMappings = embeddable.getAllAttributeMappings(MappingKeys.MANY_TO_MANY_ATTRIBUTE_MAPPING_KEY);
		1531	Iterable<AttributeMapping> oneToManyMappings = embeddable.getAllAttributeMappings(MappingKeys.ONE_TO_MANY_ATTRIBUTE_MAPPING_KEY);
		1532	if (oneToManyMappings.iterator().hasNext()) {
		1533	relationshipMapping = (RelationshipMapping)oneToManyMappings.iterator().next();
		1534	prohibitedMappingFound = true;
		1535	}
		1536	if (manyToManyMappings.iterator().hasNext()) {
		1537	relationshipMapping = (RelationshipMapping)manyToManyMappings.iterator().next();
		1538	prohibitedMappingFound = true;
		1539	}
		1540	Iterable<AttributeMapping> manyToOneMappings = embeddable.getAllAttributeMappings(MappingKeys.MANY_TO_ONE_ATTRIBUTE_MAPPING_KEY);
		1541	if (manyToOneMappings.iterator().hasNext()) {
		1542	relationshipMapping = (RelationshipMapping)manyToOneMappings.iterator().next();
		1543	if (((RelationshipMapping)manyToOneMappings.iterator().next()).getRelationshipOwner() != null
		1544	\|\| ((ManyToOneRelationship2_0)relationshipMapping.getRelationship()).getJoinTableStrategy().getJoinTable() != null) {
		1545	prohibitedMappingFound = true;
1546	}
1547	}
1548	Iterable<AttributeMapping> oneToOneMappings = embeddable.getAllAttributeMappings(MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY);
1549	if (oneToOneMappings.iterator().hasNext()) {
1550	relationshipMapping = (RelationshipMapping)oneToOneMappings.iterator().next();
1551	if (relationshipMapping.getRelationshipOwner() != null) {
1552	prohibitedMappingFound = true;
1553	}
1554	}
1555	if (prohibitedMappingFound) {
1556	if (getPersistentAttribute().isVirtual()) {
1557	messages.add(
1558	DefaultJpaValidationMessages.buildMessage(
1559	IMessage.HIGH_SEVERITY,
1560	JpaValidationMessages.VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_PROHIBITED_RELATIONSHIP_MAPPING,
1561	new String[] {this.getName(),
1562	embeddable.getName(), relationshipMapping.getName()},
1563	this,
1564	this.getValidationTextRange(astRoot)
1565	)
1566	);
1567	} else {
1568	messages.add(
1569	DefaultJpaValidationMessages.buildMessage(
1570	IMessage.HIGH_SEVERITY,
1571	JpaValidationMessages.ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_PROHIBITED_RELATIONSHIP_MAPPING,
1572	new String[] {embeddable.getName(), relationshipMapping.getName()},
1573	this,
1574	this.getValidationTextRange(astRoot)
1575	)
1576	);
1577	}
1578	}
1579	}
1580
1581	private void embeddableContainsElementCollection(List<IMessage> messages, CompilationUnit astRoot, Embeddable embeddable) {
1582	Iterable<AttributeMapping> elementCollectionMappings = embeddable.getAllAttributeMappings(MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
1583	if (elementCollectionMappings.iterator().hasNext()) {
1584	if (getPersistentAttribute().isVirtual()) {
1585	messages.add(
1586	DefaultJpaValidationMessages.buildMessage(
1587	IMessage.HIGH_SEVERITY,
1588	JpaValidationMessages.VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_ELEMENT_COLLECTION_MAPPING,
1589	new String[] {this.getName(), embeddable.getName(), elementCollectionMappings.iterator().next().getName()},
1590	this,
1591	this.getValidationTextRange(astRoot)
1592	)
1593	);
1594	} else {
1595	messages.add(
1596	DefaultJpaValidationMessages.buildMessage(
1597	IMessage.HIGH_SEVERITY,
1598	JpaValidationMessages.ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_ELEMENT_COLLECTION_MAPPING,
1599	new String[] {embeddable.getName(), elementCollectionMappings.iterator().next().getName()},
1600	this,
1601	this.getValidationTextRange(astRoot)
1602	)
1603	);
1604	}
1605	}
1477	}	1606	}
1478		1607
1479	protected void validateTargetClass(List<IMessage> messages, CompilationUnit astRoot) {	1608	protected void validateTargetClass(List<IMessage> messages, CompilationUnit astRoot) {

Lines 16-21 Link Here

(-)src/org/eclipse/jpt/jpa/core/internal/jpa2/context/orm/AbstractOrmElementCollectionMapping2_0.java (-1 / +105 lines)
16	import org.eclipse.jdt.core.IType;	16	import org.eclipse.jdt.core.IType;
17	import org.eclipse.jpt.common.core.internal.utility.JDTTools;	17	import org.eclipse.jpt.common.core.internal.utility.JDTTools;
18	import org.eclipse.jpt.common.core.utility.TextRange;	18	import org.eclipse.jpt.common.core.utility.TextRange;
		19	import org.eclipse.jpt.common.utility.internal.CollectionTools;
19	import org.eclipse.jpt.common.utility.internal.StringTools;	20	import org.eclipse.jpt.common.utility.internal.StringTools;
20	import org.eclipse.jpt.common.utility.internal.Tools;	21	import org.eclipse.jpt.common.utility.internal.Tools;
21	import org.eclipse.jpt.common.utility.internal.Transformer;	22	import org.eclipse.jpt.common.utility.internal.Transformer;
Lines 28-38 Link Here
28	import org.eclipse.jpt.common.utility.internal.iterables.SingleElementIterable;	29	import org.eclipse.jpt.common.utility.internal.iterables.SingleElementIterable;
29	import org.eclipse.jpt.common.utility.internal.iterables.SingleElementListIterable;	30	import org.eclipse.jpt.common.utility.internal.iterables.SingleElementListIterable;
30	import org.eclipse.jpt.common.utility.internal.iterables.TransformationIterable;	31	import org.eclipse.jpt.common.utility.internal.iterables.TransformationIterable;
		32	import org.eclipse.jpt.jpa.core.MappingKeys;
31	import org.eclipse.jpt.jpa.core.context.AssociationOverride;	33	import org.eclipse.jpt.jpa.core.context.AssociationOverride;
32	import org.eclipse.jpt.jpa.core.context.AssociationOverrideContainer;	34	import org.eclipse.jpt.jpa.core.context.AssociationOverrideContainer;
33	import org.eclipse.jpt.jpa.core.context.AttributeMapping;	35	import org.eclipse.jpt.jpa.core.context.AttributeMapping;
34	import org.eclipse.jpt.jpa.core.context.AttributeOverride;	36	import org.eclipse.jpt.jpa.core.context.AttributeOverride;
35	import org.eclipse.jpt.jpa.core.context.AttributeOverrideContainer;	37	import org.eclipse.jpt.jpa.core.context.AttributeOverrideContainer;
		38	import org.eclipse.jpt.jpa.core.context.BaseEmbeddedMapping;
36	import org.eclipse.jpt.jpa.core.context.Column;	39	import org.eclipse.jpt.jpa.core.context.Column;
37	import org.eclipse.jpt.jpa.core.context.Converter;	40	import org.eclipse.jpt.jpa.core.context.Converter;
38	import org.eclipse.jpt.jpa.core.context.Embeddable;	41	import org.eclipse.jpt.jpa.core.context.Embeddable;
Lines 50-55 Link Here
50	import org.eclipse.jpt.jpa.core.context.ReadOnlyOverride;	53	import org.eclipse.jpt.jpa.core.context.ReadOnlyOverride;
51	import org.eclipse.jpt.jpa.core.context.ReadOnlyTable;	54	import org.eclipse.jpt.jpa.core.context.ReadOnlyTable;
52	import org.eclipse.jpt.jpa.core.context.Relationship;	55	import org.eclipse.jpt.jpa.core.context.Relationship;
		56	import org.eclipse.jpt.jpa.core.context.RelationshipMapping;
53	import org.eclipse.jpt.jpa.core.context.Table;	57	import org.eclipse.jpt.jpa.core.context.Table;
54	import org.eclipse.jpt.jpa.core.context.TypeMapping;	58	import org.eclipse.jpt.jpa.core.context.TypeMapping;
55	import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute;	59	import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute;
Lines 93-98 Link Here
93	import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;	97	import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
94	import org.eclipse.jpt.jpa.core.jpa2.MappingKeys2_0;	98	import org.eclipse.jpt.jpa.core.jpa2.MappingKeys2_0;
95	import org.eclipse.jpt.jpa.core.jpa2.context.CollectionTable2_0;	99	import org.eclipse.jpt.jpa.core.jpa2.context.CollectionTable2_0;
		100	import org.eclipse.jpt.jpa.core.jpa2.context.ManyToOneRelationship2_0;
96	import org.eclipse.jpt.jpa.core.jpa2.context.MetamodelField;	101	import org.eclipse.jpt.jpa.core.jpa2.context.MetamodelField;
97	import org.eclipse.jpt.jpa.core.jpa2.context.Orderable2_0;	102	import org.eclipse.jpt.jpa.core.jpa2.context.Orderable2_0;
98	import org.eclipse.jpt.jpa.core.jpa2.context.orm.OrmAssociationOverrideContainer2_0;	103	import org.eclipse.jpt.jpa.core.jpa2.context.orm.OrmAssociationOverrideContainer2_0;
Lines 1472-1480 Link Here
1472	this.collectionTable.validate(messages, reporter);	1477	this.collectionTable.validate(messages, reporter);
1473	this.validateValue(messages, reporter);	1478	this.validateValue(messages, reporter);
1474	this.validateMapKey(messages, reporter);	1479	this.validateMapKey(messages, reporter);
		1480	this.validateNoEmbeddableInMappingContainsProhibittedMapping(messages);
1475	}	1481	}
1476		1482
1477	protected void validateTargetClass(List<IMessage> messages) {	1483	protected void validateNoEmbeddableInMappingContainsProhibittedMapping(List<IMessage> messages) {
		1484	Embeddable embeddableClass = getResolvedTargetEmbeddable();
		1485	if (embeddableClass != null) {
		1486	embeddableContainsElementCollection(messages, embeddableClass);
		1487	embeddableContainsProhibitedRelationshipMapping(messages, embeddableClass);
		1488	embeddableHierarchyContainsProhibittedMapping(messages, embeddableClass, new ArrayList<Embeddable>());
		1489	}
		1490	embeddableClass = getResolvedMapKeyEmbeddable();
		1491	if (embeddableClass != null) {
		1492	embeddableContainsElementCollection(messages, embeddableClass);
		1493	embeddableContainsProhibitedRelationshipMapping(messages, embeddableClass);
		1494	embeddableHierarchyContainsProhibittedMapping(messages, embeddableClass, new ArrayList<Embeddable>());
		1495	}
		1496	}
		1497
		1498	private void embeddableHierarchyContainsProhibittedMapping(List<IMessage> messages, Embeddable parentEmbeddable, List<Embeddable> visited) {
		1499	Iterable<AttributeMapping> embeddedIterable = parentEmbeddable.getAllAttributeMappings(MappingKeys.EMBEDDED_ATTRIBUTE_MAPPING_KEY);
		1500	for(AttributeMapping mapping : embeddedIterable) {
		1501	Embeddable embeddable = ((BaseEmbeddedMapping)mapping).getTargetEmbeddable();
		1502	if (embeddable != null && embeddable != parentEmbeddable) {
		1503	embeddableContainsElementCollection(messages, embeddable);
		1504	embeddableContainsProhibitedRelationshipMapping(messages, embeddable);
		1505	if (!CollectionTools.contains(visited, embeddable)) {
		1506	visited.add(embeddable);
		1507	embeddableHierarchyContainsProhibittedMapping(messages, embeddable, visited);
		1508	}
		1509	}
		1510	}
		1511	Iterable<AttributeMapping> embeddedIdIterable = parentEmbeddable.getAllAttributeMappings(MappingKeys.EMBEDDED_ID_ATTRIBUTE_MAPPING_KEY);
		1512	for(AttributeMapping mapping : embeddedIdIterable) {
		1513	Embeddable embeddable = ((BaseEmbeddedMapping)mapping).getTargetEmbeddable();
		1514	if (embeddable != null && embeddable != parentEmbeddable) {
		1515	embeddableContainsElementCollection(messages, embeddable);
		1516	embeddableContainsProhibitedRelationshipMapping(messages, embeddable);
		1517	if (!CollectionTools.contains(visited, embeddable)) {
		1518	visited.add(embeddable);
		1519	embeddableHierarchyContainsProhibittedMapping(messages, embeddable, visited);
		1520	}
		1521	}
		1522	}
		1523	}
		1524
		1525	private void embeddableContainsProhibitedRelationshipMapping(List<IMessage> messages, Embeddable embeddable) {
		1526	boolean prohibitedMappingFound = false;
		1527	RelationshipMapping relationshipMapping = null;
		1528	Iterable<AttributeMapping> manyToManyMappings = embeddable.getAllAttributeMappings(MappingKeys.MANY_TO_MANY_ATTRIBUTE_MAPPING_KEY);
		1529	Iterable<AttributeMapping> oneToManyMappings = embeddable.getAllAttributeMappings(MappingKeys.ONE_TO_MANY_ATTRIBUTE_MAPPING_KEY);
		1530	if (oneToManyMappings.iterator().hasNext()) {
		1531	relationshipMapping = (RelationshipMapping)oneToManyMappings.iterator().next();
		1532	prohibitedMappingFound = true;
		1533	}
		1534	if (manyToManyMappings.iterator().hasNext()) {
		1535	relationshipMapping = (RelationshipMapping)manyToManyMappings.iterator().next();
		1536	prohibitedMappingFound = true;
		1537	}
		1538	Iterable<AttributeMapping> manyToOneMappings = embeddable.getAllAttributeMappings(MappingKeys.MANY_TO_ONE_ATTRIBUTE_MAPPING_KEY);
		1539	if (manyToOneMappings.iterator().hasNext()) {
		1540	relationshipMapping = (RelationshipMapping)manyToOneMappings.iterator().next();
		1541	if (((RelationshipMapping)manyToOneMappings.iterator().next()).getRelationshipOwner() != null
		1542	\|\|((ManyToOneRelationship2_0)relationshipMapping.getRelationship()).getJoinTableStrategy().getJoinTable() != null) {
		1543	prohibitedMappingFound = true;
		1544	}
		1545	}
		1546	Iterable<AttributeMapping> oneToOneMappings = embeddable.getAllAttributeMappings(MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY);
		1547	if (oneToOneMappings.iterator().hasNext()) {
1548	relationshipMapping = (RelationshipMapping)oneToOneMappings.iterator().next();
1549	if (((RelationshipMapping)oneToOneMappings.iterator().next()).getRelationshipOwner() != null) {
1550	prohibitedMappingFound = true;
1551	}
1552	}
1553	if (prohibitedMappingFound) {
1554	messages.add(
1555	DefaultJpaValidationMessages.buildMessage(
1556	IMessage.HIGH_SEVERITY,
1557	JpaValidationMessages.ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_PROHIBITED_RELATIONSHIP_MAPPING,
1558	new String[] {embeddable.getName(), relationshipMapping.getName()},
1559	this,
1560	this.getValidationTextRange()
1561	)
1562	);
1563	}
1564	}
1565
1566	private void embeddableContainsElementCollection(List<IMessage> messages, Embeddable embeddable) {
1567	Iterable<AttributeMapping> elementCollectionMappings = embeddable.getAllAttributeMappings(MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
1568	if (elementCollectionMappings.iterator().hasNext()) {
1569	messages.add(
1570	DefaultJpaValidationMessages.buildMessage(
1571	IMessage.HIGH_SEVERITY,
1572	JpaValidationMessages.ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_ELEMENT_COLLECTION_MAPPING,
1573	new String[] {embeddable.getName(), elementCollectionMappings.iterator().next().getName()},
1574	this,
1575	this.getValidationTextRange()
1576	)
1577	);
1578	}
1579	}
1580
1581	protected void validateTargetClass(List<IMessage> messages) {
1478	if (StringTools.stringIsEmpty(this.getTargetClass())) {	1582	if (StringTools.stringIsEmpty(this.getTargetClass())) {
1479	messages.add(	1583	messages.add(
1480	DefaultJpaValidationMessages.buildMessage(	1584	DefaultJpaValidationMessages.buildMessage(

Lines 93-98 Link Here

(-)src/org/eclipse/jpt/jpa/core/internal/validation/JpaValidationMessages.java (+4 lines)
93	public static final String MAP_KEY_CLASS_NOT_DEFINED = "MAP_KEY_CLASS_NOT_DEFINED";	93	public static final String MAP_KEY_CLASS_NOT_DEFINED = "MAP_KEY_CLASS_NOT_DEFINED";
94	public static final String MAP_KEY_CLASS_NOT_EXIST = "MAP_KEY_CLASS_NOT_EXIST";	94	public static final String MAP_KEY_CLASS_NOT_EXIST = "MAP_KEY_CLASS_NOT_EXIST";
95	public static final String ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST = "ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST";	95	public static final String ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST = "ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST";
		96	public static final String ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_ELEMENT_COLLECTION_MAPPING = "ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_ELEMENT_COLLECTION_MAPPING";
		97	public static final String ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_PROHIBITED_RELATIONSHIP_MAPPING = "ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_PROHIBITED_RELATIONSHIP_MAPPING";
96	public static final String ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE = "ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE";	98	public static final String ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE = "ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE";
97	public static final String ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED = "ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED";	99	public static final String ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED = "ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED";
98	public static final String EMBEDDED_ID_MAPPING_MAPPED_BY_RELATIONSHIP_AND_ATTRIBUTE_OVERRIDES_SPECIFIED = "EMBEDDED_ID_MAPPING_MAPPED_BY_RELATIONSHIP_AND_ATTRIBUTE_OVERRIDES_SPECIFIED";	100	public static final String EMBEDDED_ID_MAPPING_MAPPED_BY_RELATIONSHIP_AND_ATTRIBUTE_OVERRIDES_SPECIFIED = "EMBEDDED_ID_MAPPING_MAPPED_BY_RELATIONSHIP_AND_ATTRIBUTE_OVERRIDES_SPECIFIED";
Lines 123-128 Link Here
123	//*Implied Attribute*	125	//*Implied Attribute*
124	public static final String VIRTUAL_ATTRIBUTE_MAP_KEY_CLASS_NOT_DEFINED = "VIRTUAL_ATTRIBUTE_MAP_KEY_CLASS_NOT_DEFINED";	126	public static final String VIRTUAL_ATTRIBUTE_MAP_KEY_CLASS_NOT_DEFINED = "VIRTUAL_ATTRIBUTE_MAP_KEY_CLASS_NOT_DEFINED";
125	public static final String VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST = "VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST";	127	public static final String VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST = "VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST";
		128	public static final String VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_ELEMENT_COLLECTION_MAPPING = "VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_ELEMENT_COLLECTION_MAPPING";
		129	public static final String VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_PROHIBITED_RELATIONSHIP_MAPPING = "VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_PROHIBITED_RELATIONSHIP_MAPPING";
126	public static final String VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE = "VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE";	130	public static final String VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE = "VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE";
127	public static final String VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED = "VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED";	131	public static final String VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED = "VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED";
128	public static final String VIRTUAL_ATTRIBUTE_TARGET_ENTITY_IS_NOT_AN_ENTITY = "VIRTUAL_ATTRIBUTE_TARGET_ENTITY_IS_NOT_AN_ENTITY";	132	public static final String VIRTUAL_ATTRIBUTE_TARGET_ENTITY_IS_NOT_AN_ENTITY = "VIRTUAL_ATTRIBUTE_TARGET_ENTITY_IS_NOT_AN_ENTITY";

Lines 88-93 Link Here

(-)property_files/jpt_ui_validation_preferences.properties (+4 lines)
88	ATTRIBUTE_LEVEL_CATEGORY=Attribute	88	ATTRIBUTE_LEVEL_CATEGORY=Attribute
89		89
90	ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST=Element collection target class does not exist on the project classpath:	90	ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST=Element collection target class does not exist on the project classpath:
		91	ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_ELEMENT_COLLECTION_MAPPING=Element collection mapping contains an embeddable which contains a prohibited element collection mapping:
		92	ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_PROHIBITED_RELATIONSHIP_MAPPING=Element collection mapping contains an embeddable which contains a prohibited relationship mapping:
91	ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE=Element collection target class is not embeddable or basic type:	93	ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE=Element collection target class is not embeddable or basic type:
92	ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED=Element collection target class is not specified:	94	ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED=Element collection target class is not specified:
93	EMBEDDED_ID_MAPPING_MAPPED_BY_RELATIONSHIP_AND_ATTRIBUTE_OVERRIDES_SPECIFIED=Embedded IDs that are mapped by a relationship should not specify any attribute overrides:	95	EMBEDDED_ID_MAPPING_MAPPED_BY_RELATIONSHIP_AND_ATTRIBUTE_OVERRIDES_SPECIFIED=Embedded IDs that are mapped by a relationship should not specify any attribute overrides:
Lines 118-123 Link Here
118	MAP_KEY_CLASS_NOT_EXIST=Map key class does not exist on the project classpath:	120	MAP_KEY_CLASS_NOT_EXIST=Map key class does not exist on the project classpath:
119		121
120	VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST=Element collection target class does not exist on the project classpath:	122	VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST=Element collection target class does not exist on the project classpath:
		123	VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_ELEMENT_COLLECTION_MAPPING=Element collection mapping contains an embeddable which contains a prohibited element collection mapping:
		124	VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_PROHIBITED_RELATIONSHIP_MAPPING=Element collection mapping contains an embeddable which contains a prohibited relationship mapping:
121	VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE=Element collection target class is not embeddable or basic type:	125	VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE=Element collection target class is not embeddable or basic type:
122	VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED=Element collection target class is not specified:	126	VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED=Element collection target class is not specified:
123	VIRTUAL_ATTRIBUTE_TARGET_ENTITY_IS_NOT_AN_ENTITY=Target entity is not an Entity:	127	VIRTUAL_ATTRIBUTE_TARGET_ENTITY_IS_NOT_AN_ENTITY=Target entity is not an Entity:

Lines 97-102 Link Here

(-)src/org/eclipse/jpt/jpa/ui/internal/JptUiValidationPreferenceMessages.java (+4 lines)
97	public static String ATTRIBUTE_LEVEL_CATEGORY;	97	public static String ATTRIBUTE_LEVEL_CATEGORY;
98		98
99	public static String ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST;// 3.0 M7	99	public static String ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST;// 3.0 M7
		100	public static String ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_ELEMENT_COLLECTION_MAPPING;
		101	public static String ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_PROHIBITED_RELATIONSHIP_MAPPING;
100	public static String ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE;	102	public static String ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE;
101	public static String ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED;	103	public static String ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED;
102	public static String EMBEDDED_ID_MAPPING_MAPPED_BY_RELATIONSHIP_AND_ATTRIBUTE_OVERRIDES_SPECIFIED; //3.0 M7	104	public static String EMBEDDED_ID_MAPPING_MAPPED_BY_RELATIONSHIP_AND_ATTRIBUTE_OVERRIDES_SPECIFIED; //3.0 M7
Lines 127-132 Link Here
127	public static String MAP_KEY_CLASS_NOT_EXIST;	129	public static String MAP_KEY_CLASS_NOT_EXIST;
128	// ---------- Implied Attributes ------------	130	// ---------- Implied Attributes ------------
129	public static String VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST;	131	public static String VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST;
		132	public static String VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_ELEMENT_COLLECTION_MAPPING;
		133	public static String VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_PROHIBITED_RELATIONSHIP_MAPPING;
130	public static String VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE;	134	public static String VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE;
131	public static String VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED;	135	public static String VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED;
132	public static String VIRTUAL_ATTRIBUTE_TARGET_ENTITY_IS_NOT_AN_ENTITY;	136	public static String VIRTUAL_ATTRIBUTE_TARGET_ENTITY_IS_NOT_AN_ENTITY;

Lines 368-373 Link Here

(-)src/org/eclipse/jpt/jpa/ui/internal/preferences/JpaProblemSeveritiesPage.java (+4 lines)
368	addLabeledCombo(parent, JptUiValidationPreferenceMessages.ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE, JpaValidationMessages.ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE);	368	addLabeledCombo(parent, JptUiValidationPreferenceMessages.ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE, JpaValidationMessages.ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE);
369	addLabeledCombo(parent, JptUiValidationPreferenceMessages.ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST, JpaValidationMessages.ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST); //3.0 M7	369	addLabeledCombo(parent, JptUiValidationPreferenceMessages.ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST, JpaValidationMessages.ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST); //3.0 M7
370	addLabeledCombo(parent, JptUiValidationPreferenceMessages.ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED, JpaValidationMessages.ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED);	370	addLabeledCombo(parent, JptUiValidationPreferenceMessages.ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED, JpaValidationMessages.ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED);
		371	addLabeledCombo(parent, JptUiValidationPreferenceMessages.ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_ELEMENT_COLLECTION_MAPPING, JpaValidationMessages.ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_ELEMENT_COLLECTION_MAPPING);
		372	addLabeledCombo(parent, JptUiValidationPreferenceMessages.ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_PROHIBITED_RELATIONSHIP_MAPPING, JpaValidationMessages.ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_PROHIBITED_RELATIONSHIP_MAPPING);
371	addLabeledCombo(parent, JptUiValidationPreferenceMessages.EMBEDDED_ID_MAPPING_MAPPED_BY_RELATIONSHIP_AND_ATTRIBUTE_OVERRIDES_SPECIFIED, JpaValidationMessages.EMBEDDED_ID_MAPPING_MAPPED_BY_RELATIONSHIP_AND_ATTRIBUTE_OVERRIDES_SPECIFIED); //3.0 M7	373	addLabeledCombo(parent, JptUiValidationPreferenceMessages.EMBEDDED_ID_MAPPING_MAPPED_BY_RELATIONSHIP_AND_ATTRIBUTE_OVERRIDES_SPECIFIED, JpaValidationMessages.EMBEDDED_ID_MAPPING_MAPPED_BY_RELATIONSHIP_AND_ATTRIBUTE_OVERRIDES_SPECIFIED); //3.0 M7
372	addLabeledCombo(parent, JptUiValidationPreferenceMessages.ID_MAPPING_MAPPED_BY_RELATIONSHIP_AND_COLUMN_SPECIFIED, JpaValidationMessages.ID_MAPPING_MAPPED_BY_RELATIONSHIP_AND_COLUMN_SPECIFIED); //3.0 M7	374	addLabeledCombo(parent, JptUiValidationPreferenceMessages.ID_MAPPING_MAPPED_BY_RELATIONSHIP_AND_COLUMN_SPECIFIED, JpaValidationMessages.ID_MAPPING_MAPPED_BY_RELATIONSHIP_AND_COLUMN_SPECIFIED); //3.0 M7
373	addLabeledCombo(parent, JptUiValidationPreferenceMessages.MAPS_ID_VALUE_INVALID, JpaValidationMessages.MAPS_ID_VALUE_INVALID);	375	addLabeledCombo(parent, JptUiValidationPreferenceMessages.MAPS_ID_VALUE_INVALID, JpaValidationMessages.MAPS_ID_VALUE_INVALID);
Lines 397-402 Link Here
397	parent = addSubExpandableSection(parent, JptUiValidationPreferenceMessages.IMPLIED_ATTRIBUTE_LEVEL_CATEGORY);	399	parent = addSubExpandableSection(parent, JptUiValidationPreferenceMessages.IMPLIED_ATTRIBUTE_LEVEL_CATEGORY);
398		400
399	addLabeledCombo(parent, JptUiValidationPreferenceMessages.VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST, JpaValidationMessages.VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST);	401	addLabeledCombo(parent, JptUiValidationPreferenceMessages.VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST, JpaValidationMessages.VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST);
		402	addLabeledCombo(parent, JptUiValidationPreferenceMessages.VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_ELEMENT_COLLECTION_MAPPING, JpaValidationMessages.VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_ELEMENT_COLLECTION_MAPPING);
		403	addLabeledCombo(parent, JptUiValidationPreferenceMessages.VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_PROHIBITED_RELATIONSHIP_MAPPING, JpaValidationMessages.VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_PROHIBITED_RELATIONSHIP_MAPPING);
400	addLabeledCombo(parent, JptUiValidationPreferenceMessages.VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE, JpaValidationMessages.VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE);	404	addLabeledCombo(parent, JptUiValidationPreferenceMessages.VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE, JpaValidationMessages.VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE);
401	addLabeledCombo(parent, JptUiValidationPreferenceMessages.VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED, JpaValidationMessages.VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED);	405	addLabeledCombo(parent, JptUiValidationPreferenceMessages.VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED, JpaValidationMessages.VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED);
402	addLabeledCombo(parent, JptUiValidationPreferenceMessages.VIRTUAL_ATTRIBUTE_TARGET_ENTITY_IS_NOT_AN_ENTITY, JpaValidationMessages.VIRTUAL_ATTRIBUTE_TARGET_ENTITY_IS_NOT_AN_ENTITY);	406	addLabeledCombo(parent, JptUiValidationPreferenceMessages.VIRTUAL_ATTRIBUTE_TARGET_ENTITY_IS_NOT_AN_ENTITY, JpaValidationMessages.VIRTUAL_ATTRIBUTE_TARGET_ENTITY_IS_NOT_AN_ENTITY);