Attachment #211374 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.OneToOneRelationship2_0;
import org.eclipse.jpt.jpa.core.jpa2.context.Orderable2_0;
import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaAssociationOverrideContainer2_0;
import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaAttributeOverrideContainer2_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
					|| ((OneToOneRelationship2_0)relationshipMapping.getRelationship()).getJoinTableStrategy().getJoinTable() != 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.OneToOneRelationship2_0;
import org.eclipse.jpt.jpa.core.jpa2.context.Orderable2_0;
import org.eclipse.jpt.jpa.core.jpa2.context.orm.OrmAssociationOverrideContainer2_0;
import org.eclipse.jpt.jpa.core.jpa2.context.orm.OrmCollectionTable2_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
						|| ((OneToOneRelationship2_0)relationshipMapping.getRelationship()).getJoinTableStrategy().getJoinTable() != 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 (+131 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-102 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;
		105	import org.eclipse.jpt.jpa.core.jpa2.context.OneToOneRelationship2_0;
100	import org.eclipse.jpt.jpa.core.jpa2.context.Orderable2_0;	106	import org.eclipse.jpt.jpa.core.jpa2.context.Orderable2_0;
101	import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaAssociationOverrideContainer2_0;	107	import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaAssociationOverrideContainer2_0;
102	import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaAttributeOverrideContainer2_0;	108	import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaAttributeOverrideContainer2_0;
Lines 1474-1479 Link Here
1474	this.collectionTable.validate(messages, reporter, astRoot);	1480	this.collectionTable.validate(messages, reporter, astRoot);
1475	this.validateValue(messages, reporter, astRoot);	1481	this.validateValue(messages, reporter, astRoot);
1476	this.validateMapKey(messages, reporter, astRoot);	1482	this.validateMapKey(messages, reporter, astRoot);
		1483	this.validateNoEmbeddableInMappingContainsProhibittedMapping(messages, astRoot);
		1484	}
		1485
		1486	protected void validateNoEmbeddableInMappingContainsProhibittedMapping(List<IMessage> messages, CompilationUnit astRoot) {
		1487	Embeddable embeddableClass = getResolvedTargetEmbeddable();
		1488	if (embeddableClass != null) {
		1489	embeddableContainsElementCollection(messages, astRoot, embeddableClass);
		1490	embeddableContainsProhibitedRelationshipMapping(messages, astRoot, embeddableClass);
		1491	embeddableHierarchyContainsProhibittedMapping(messages, astRoot, embeddableClass, new ArrayList<Embeddable>());
		1492	}
		1493	embeddableClass = getResolvedMapKeyEmbeddable();
		1494	if (embeddableClass != null) {
		1495	embeddableContainsElementCollection(messages, astRoot, embeddableClass);
		1496	embeddableContainsProhibitedRelationshipMapping(messages, astRoot, embeddableClass);
		1497	embeddableHierarchyContainsProhibittedMapping(messages, astRoot, embeddableClass, new ArrayList<Embeddable>());
		1498	}
		1499	}
		1500
		1501	private void embeddableHierarchyContainsProhibittedMapping(List<IMessage> messages, CompilationUnit astRoot, Embeddable parentEmbeddable, List<Embeddable> visited) {
		1502	Iterable<AttributeMapping> embeddedIterable = parentEmbeddable.getAllAttributeMappings(MappingKeys.EMBEDDED_ATTRIBUTE_MAPPING_KEY);
		1503	for(AttributeMapping mapping : embeddedIterable) {
		1504	Embeddable embeddable = ((BaseEmbeddedMapping)mapping).getTargetEmbeddable();
		1505	if (embeddable != null && embeddable != parentEmbeddable) {
		1506	embeddableContainsElementCollection(messages, astRoot, embeddable);
		1507	embeddableContainsProhibitedRelationshipMapping(messages, astRoot, embeddable);
		1508	if (!CollectionTools.contains(visited, embeddable)) {
		1509	visited.add(embeddable);
		1510	embeddableHierarchyContainsProhibittedMapping(messages, astRoot, embeddable, visited);
		1511	}
		1512	}
		1513	}
		1514	Iterable<AttributeMapping> embeddedIdIterable = parentEmbeddable.getAllAttributeMappings(MappingKeys.EMBEDDED_ID_ATTRIBUTE_MAPPING_KEY);
		1515	for(AttributeMapping mapping : embeddedIdIterable) {
		1516	Embeddable embeddable = ((BaseEmbeddedMapping)mapping).getTargetEmbeddable();
		1517	if (embeddable != null && embeddable != parentEmbeddable) {
		1518	embeddableContainsElementCollection(messages, astRoot, embeddable);
		1519	embeddableContainsProhibitedRelationshipMapping(messages, astRoot, embeddable);
		1520	if (!CollectionTools.contains(visited, embeddable)) {
		1521	visited.add(embeddable);
		1522	embeddableHierarchyContainsProhibittedMapping(messages, astRoot, embeddable, visited);
		1523	}
		1524	}
		1525	}
		1526	}
		1527
		1528	private void embeddableContainsProhibitedRelationshipMapping(List<IMessage> messages, CompilationUnit astRoot, Embeddable embeddable) {
		1529	boolean prohibitedMappingFound = false;
		1530	RelationshipMapping relationshipMapping = null;
		1531	Iterable<AttributeMapping> manyToManyMappings = embeddable.getAllAttributeMappings(MappingKeys.MANY_TO_MANY_ATTRIBUTE_MAPPING_KEY);
		1532	Iterable<AttributeMapping> oneToManyMappings = embeddable.getAllAttributeMappings(MappingKeys.ONE_TO_MANY_ATTRIBUTE_MAPPING_KEY);
		1533	if (oneToManyMappings.iterator().hasNext()) {
		1534	relationshipMapping = (RelationshipMapping)oneToManyMappings.iterator().next();
		1535	prohibitedMappingFound = true;
		1536	}
		1537	if (manyToManyMappings.iterator().hasNext()) {
		1538	relationshipMapping = (RelationshipMapping)manyToManyMappings.iterator().next();
		1539	prohibitedMappingFound = true;
		1540	}
		1541	Iterable<AttributeMapping> manyToOneMappings = embeddable.getAllAttributeMappings(MappingKeys.MANY_TO_ONE_ATTRIBUTE_MAPPING_KEY);
		1542	if (manyToOneMappings.iterator().hasNext()) {
		1543	relationshipMapping = (RelationshipMapping)manyToOneMappings.iterator().next();
		1544	if (((RelationshipMapping)manyToOneMappings.iterator().next()).getRelationshipOwner() != null
		1545	\|\| ((ManyToOneRelationship2_0)relationshipMapping.getRelationship()).getJoinTableStrategy().getJoinTable() != null) {
		1546	prohibitedMappingFound = true;
1547	}
1548	}
1549	Iterable<AttributeMapping> oneToOneMappings = embeddable.getAllAttributeMappings(MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY);
1550	if (oneToOneMappings.iterator().hasNext()) {
1551	relationshipMapping = (RelationshipMapping)oneToOneMappings.iterator().next();
1552	if (relationshipMapping.getRelationshipOwner() != null
1553	\|\| ((OneToOneRelationship2_0)relationshipMapping.getRelationship()).getJoinTableStrategy().getJoinTable() != null) {
1554	prohibitedMappingFound = true;
1555	}
1556	}
1557	if (prohibitedMappingFound) {
1558	if (getPersistentAttribute().isVirtual()) {
1559	messages.add(
1560	DefaultJpaValidationMessages.buildMessage(
1561	IMessage.HIGH_SEVERITY,
1562	JpaValidationMessages.VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_PROHIBITED_RELATIONSHIP_MAPPING,
1563	new String[] {this.getName(),
1564	embeddable.getName(), relationshipMapping.getName()},
1565	this,
1566	this.getValidationTextRange(astRoot)
1567	)
1568	);
1569	} else {
1570	messages.add(
1571	DefaultJpaValidationMessages.buildMessage(
1572	IMessage.HIGH_SEVERITY,
1573	JpaValidationMessages.ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_PROHIBITED_RELATIONSHIP_MAPPING,
1574	new String[] {embeddable.getName(), relationshipMapping.getName()},
1575	this,
1576	this.getValidationTextRange(astRoot)
1577	)
1578	);
1579	}
1580	}
1581	}
1582
1583	private void embeddableContainsElementCollection(List<IMessage> messages, CompilationUnit astRoot, Embeddable embeddable) {
1584	Iterable<AttributeMapping> elementCollectionMappings = embeddable.getAllAttributeMappings(MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
1585	if (elementCollectionMappings.iterator().hasNext()) {
1586	if (getPersistentAttribute().isVirtual()) {
1587	messages.add(
1588	DefaultJpaValidationMessages.buildMessage(
1589	IMessage.HIGH_SEVERITY,
1590	JpaValidationMessages.VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_ELEMENT_COLLECTION_MAPPING,
1591	new String[] {this.getName(), embeddable.getName(), elementCollectionMappings.iterator().next().getName()},
1592	this,
1593	this.getValidationTextRange(astRoot)
1594	)
1595	);
1596	} else {
1597	messages.add(
1598	DefaultJpaValidationMessages.buildMessage(
1599	IMessage.HIGH_SEVERITY,
1600	JpaValidationMessages.ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_ELEMENT_COLLECTION_MAPPING,
1601	new String[] {embeddable.getName(), elementCollectionMappings.iterator().next().getName()},
1602	this,
1603	this.getValidationTextRange(astRoot)
1604	)
1605	);
1606	}
1607	}
1477	}	1608	}
1478		1609
1479	protected void validateTargetClass(List<IMessage> messages, CompilationUnit astRoot) {	1610	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 / +107 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-99 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;
		102	import org.eclipse.jpt.jpa.core.jpa2.context.OneToOneRelationship2_0;
97	import org.eclipse.jpt.jpa.core.jpa2.context.Orderable2_0;	103	import org.eclipse.jpt.jpa.core.jpa2.context.Orderable2_0;
98	import org.eclipse.jpt.jpa.core.jpa2.context.orm.OrmAssociationOverrideContainer2_0;	104	import org.eclipse.jpt.jpa.core.jpa2.context.orm.OrmAssociationOverrideContainer2_0;
99	import org.eclipse.jpt.jpa.core.jpa2.context.orm.OrmCollectionTable2_0;	105	import org.eclipse.jpt.jpa.core.jpa2.context.orm.OrmCollectionTable2_0;
Lines 1472-1480 Link Here
1472	this.collectionTable.validate(messages, reporter);	1478	this.collectionTable.validate(messages, reporter);
1473	this.validateValue(messages, reporter);	1479	this.validateValue(messages, reporter);
1474	this.validateMapKey(messages, reporter);	1480	this.validateMapKey(messages, reporter);
		1481	this.validateNoEmbeddableInMappingContainsProhibittedMapping(messages);
1475	}	1482	}
1476		1483
1477	protected void validateTargetClass(List<IMessage> messages) {	1484	protected void validateNoEmbeddableInMappingContainsProhibittedMapping(List<IMessage> messages) {
		1485	Embeddable embeddableClass = getResolvedTargetEmbeddable();
		1486	if (embeddableClass != null) {
		1487	embeddableContainsElementCollection(messages, embeddableClass);
		1488	embeddableContainsProhibitedRelationshipMapping(messages, embeddableClass);
		1489	embeddableHierarchyContainsProhibittedMapping(messages, embeddableClass, new ArrayList<Embeddable>());
		1490	}
		1491	embeddableClass = getResolvedMapKeyEmbeddable();
		1492	if (embeddableClass != null) {
		1493	embeddableContainsElementCollection(messages, embeddableClass);
		1494	embeddableContainsProhibitedRelationshipMapping(messages, embeddableClass);
		1495	embeddableHierarchyContainsProhibittedMapping(messages, embeddableClass, new ArrayList<Embeddable>());
		1496	}
		1497	}
		1498
		1499	private void embeddableHierarchyContainsProhibittedMapping(List<IMessage> messages, Embeddable parentEmbeddable, List<Embeddable> visited) {
		1500	Iterable<AttributeMapping> embeddedIterable = parentEmbeddable.getAllAttributeMappings(MappingKeys.EMBEDDED_ATTRIBUTE_MAPPING_KEY);
		1501	for(AttributeMapping mapping : embeddedIterable) {
		1502	Embeddable embeddable = ((BaseEmbeddedMapping)mapping).getTargetEmbeddable();
		1503	if (embeddable != null && embeddable != parentEmbeddable) {
		1504	embeddableContainsElementCollection(messages, embeddable);
		1505	embeddableContainsProhibitedRelationshipMapping(messages, embeddable);
		1506	if (!CollectionTools.contains(visited, embeddable)) {
		1507	visited.add(embeddable);
		1508	embeddableHierarchyContainsProhibittedMapping(messages, embeddable, visited);
		1509	}
		1510	}
		1511	}
		1512	Iterable<AttributeMapping> embeddedIdIterable = parentEmbeddable.getAllAttributeMappings(MappingKeys.EMBEDDED_ID_ATTRIBUTE_MAPPING_KEY);
		1513	for(AttributeMapping mapping : embeddedIdIterable) {
		1514	Embeddable embeddable = ((BaseEmbeddedMapping)mapping).getTargetEmbeddable();
		1515	if (embeddable != null && embeddable != parentEmbeddable) {
		1516	embeddableContainsElementCollection(messages, embeddable);
		1517	embeddableContainsProhibitedRelationshipMapping(messages, embeddable);
		1518	if (!CollectionTools.contains(visited, embeddable)) {
		1519	visited.add(embeddable);
		1520	embeddableHierarchyContainsProhibittedMapping(messages, embeddable, visited);
		1521	}
		1522	}
		1523	}
		1524	}
		1525
		1526	private void embeddableContainsProhibitedRelationshipMapping(List<IMessage> messages, Embeddable embeddable) {
		1527	boolean prohibitedMappingFound = false;
		1528	RelationshipMapping relationshipMapping = null;
		1529	Iterable<AttributeMapping> manyToManyMappings = embeddable.getAllAttributeMappings(MappingKeys.MANY_TO_MANY_ATTRIBUTE_MAPPING_KEY);
		1530	Iterable<AttributeMapping> oneToManyMappings = embeddable.getAllAttributeMappings(MappingKeys.ONE_TO_MANY_ATTRIBUTE_MAPPING_KEY);
		1531	if (oneToManyMappings.iterator().hasNext()) {
		1532	relationshipMapping = (RelationshipMapping)oneToManyMappings.iterator().next();
		1533	prohibitedMappingFound = true;
		1534	}
		1535	if (manyToManyMappings.iterator().hasNext()) {
		1536	relationshipMapping = (RelationshipMapping)manyToManyMappings.iterator().next();
		1537	prohibitedMappingFound = true;
		1538	}
		1539	Iterable<AttributeMapping> manyToOneMappings = embeddable.getAllAttributeMappings(MappingKeys.MANY_TO_ONE_ATTRIBUTE_MAPPING_KEY);
		1540	if (manyToOneMappings.iterator().hasNext()) {
		1541	relationshipMapping = (RelationshipMapping)manyToOneMappings.iterator().next();
		1542	if (((RelationshipMapping)manyToOneMappings.iterator().next()).getRelationshipOwner() != null
		1543	\|\|((ManyToOneRelationship2_0)relationshipMapping.getRelationship()).getJoinTableStrategy().getJoinTable() != null) {
		1544	prohibitedMappingFound = true;
		1545	}
		1546	}
		1547	Iterable<AttributeMapping> oneToOneMappings = embeddable.getAllAttributeMappings(MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY);
		1548	if (oneToOneMappings.iterator().hasNext()) {
1549	relationshipMapping = (RelationshipMapping)oneToOneMappings.iterator().next();
1550	if (((RelationshipMapping)oneToOneMappings.iterator().next()).getRelationshipOwner() != null
1551	\|\| ((OneToOneRelationship2_0)relationshipMapping.getRelationship()).getJoinTableStrategy().getJoinTable() != null) {
1552	prohibitedMappingFound = true;
1553	}
1554	}
1555	if (prohibitedMappingFound) {
1556	messages.add(
1557	DefaultJpaValidationMessages.buildMessage(
1558	IMessage.HIGH_SEVERITY,
1559	JpaValidationMessages.ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_PROHIBITED_RELATIONSHIP_MAPPING,
1560	new String[] {embeddable.getName(), relationshipMapping.getName()},
1561	this,
1562	this.getValidationTextRange()
1563	)
1564	);
1565	}
1566	}
1567
1568	private void embeddableContainsElementCollection(List<IMessage> messages, Embeddable embeddable) {
1569	Iterable<AttributeMapping> elementCollectionMappings = embeddable.getAllAttributeMappings(MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
1570	if (elementCollectionMappings.iterator().hasNext()) {
1571	messages.add(
1572	DefaultJpaValidationMessages.buildMessage(
1573	IMessage.HIGH_SEVERITY,
1574	JpaValidationMessages.ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_ELEMENT_COLLECTION_MAPPING,
1575	new String[] {embeddable.getName(), elementCollectionMappings.iterator().next().getName()},
1576	this,
1577	this.getValidationTextRange()
1578	)
1579	);
1580	}
1581	}
1582
1583	protected void validateTargetClass(List<IMessage> messages) {
1478	if (StringTools.stringIsEmpty(this.getTargetClass())) {	1584	if (StringTools.stringIsEmpty(this.getTargetClass())) {
1479	messages.add(	1585	messages.add(
1480	DefaultJpaValidationMessages.buildMessage(	1586	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);