Attachment #190910 for bug #325162

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

Lines 185-190 Link Here

(-)property_files/jpa_validation.properties (+2 lines)
185	VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_MAP_KEY_CLASS_NOT_DEFINED=In implied attribute \"{0}\", map key class is not defined	185	VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_MAP_KEY_CLASS_NOT_DEFINED=In implied attribute \"{0}\", map key class is not defined
186	ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE=Target class \"{0}\" is not an embeddable or basic type	186	ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE=Target class \"{0}\" is not an embeddable or basic type
187	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	187	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
		188	ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_ELEMENT_COLLECTION_MAPPING=Mapping contains an embeddable \"{0}\" which contains an element collection mapping, element collections may not contain embeddables with element collection mappings.
		189	ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_PROHIBITED_RELATIONSHIP_MAPPING=Mapping contains an embeddable \"{0}\" which contains a prohibited entity relationship mapping. Embeddables in element collections may only contain many-to-one or one-to-one mappings and be on the \"owning\" side of the relationship.
188	MAP_KEY_COLUMN_UNRESOLVED_NAME = Map key column \"{0}\" cannot be resolved on table \"{1}\"	190	MAP_KEY_COLUMN_UNRESOLVED_NAME = Map key column \"{0}\" cannot be resolved on table \"{1}\"
189	VIRTUAL_ATTRIBUTE_MAP_KEY_COLUMN_UNRESOLVED_NAME = In implied attribute \"{0}\", map key column \"{1}\" cannot be resolved on table \"{2}\"	191	VIRTUAL_ATTRIBUTE_MAP_KEY_COLUMN_UNRESOLVED_NAME = In implied attribute \"{0}\", map key column \"{1}\" cannot be resolved on table \"{2}\"
190	COLLECTION_TABLE_UNRESOLVED_CATALOG = Catalog \"{0}\" cannot be resolved for collection table \"{1}\"	192	COLLECTION_TABLE_UNRESOLVED_CATALOG = Catalog \"{0}\" cannot be resolved for collection table \"{1}\"




import org.eclipse.jpt.common.utility.internal.iterators.FilteringIterator;
import org.eclipse.jpt.common.utility.internal.iterators.TransformationIterator;
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.BaseColumn;
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.Override_;
import org.eclipse.jpt.jpa.core.context.PersistentType;
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;

		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;
		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() || manyToManyMappings.iterator().hasNext()) {
			prohibitedMappingFound = true;
		}
		Iterable<AttributeMapping> manyToOneMappings = embeddable.getAllAttributeMappings(MappingKeys.MANY_TO_ONE_ATTRIBUTE_MAPPING_KEY);
		if (manyToOneMappings.iterator().hasNext()) {
			if (((RelationshipMapping)manyToOneMappings.iterator().next()).getRelationshipOwner() != null) {
				prohibitedMappingFound = true;
			}
		}
		Iterable<AttributeMapping> oneToOneMappings = embeddable.getAllAttributeMappings(MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY);
		if (oneToOneMappings.iterator().hasNext()) {
			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()},
					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()) {
			messages.add(
				DefaultJpaValidationMessages.buildMessage(
					IMessage.HIGH_SEVERITY,
					JpaValidationMessages.ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_ELEMENT_COLLECTION_MAPPING,
					new String[] {embeddable.getName()},
					this,
					this.getValidationTextRange(astRoot)
				)
			);							
		}
	}

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




import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.eclipse.emf.common.util.EList;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragment;

import org.eclipse.jpt.common.utility.internal.iterators.CompositeIterator;
import org.eclipse.jpt.common.utility.internal.iterators.EmptyIterator;
import org.eclipse.jpt.common.utility.internal.iterators.TransformationIterator;
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.BaseColumn;
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.Override_;
import org.eclipse.jpt.jpa.core.context.PersistentType;
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.JavaAssociationOverride;

		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;
		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() || manyToManyMappings.iterator().hasNext()) {
			prohibitedMappingFound = true;
		}
		Iterable<AttributeMapping> manyToOneMappings = embeddable.getAllAttributeMappings(MappingKeys.MANY_TO_ONE_ATTRIBUTE_MAPPING_KEY);
		if (manyToOneMappings.iterator().hasNext()) {
			if (((RelationshipMapping)manyToOneMappings.iterator().next()).getRelationshipOwner() != null) {
				prohibitedMappingFound = true;
			}
		}
		Iterable<AttributeMapping> oneToOneMappings = embeddable.getAllAttributeMappings(MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY);
		if (oneToOneMappings.iterator().hasNext()) {
			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()},
					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()},
					this,
					this.getValidationTextRange()
				)
			);							
		}
	}

	protected void validateTargetClass(List<IMessage> messages) {

Lines 207-212 Link Here

(-)src/org/eclipse/jpt/jpa/core/internal/validation/JpaValidationMessages.java (+2 lines)
207	public static final String ORDER_COLUMN_AND_ORDER_BY_BOTH_SPECIFIED = "ORDER_COLUMN_AND_ORDER_BY_BOTH_SPECIFIED";	207	public static final String ORDER_COLUMN_AND_ORDER_BY_BOTH_SPECIFIED = "ORDER_COLUMN_AND_ORDER_BY_BOTH_SPECIFIED";
208	public static final String ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED = "ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED";	208	public static final String ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED = "ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED";
209	public static final String ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST = "ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST";	209	public static final String ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST = "ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST";
		210	public static final String ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_ELEMENT_COLLECTION_MAPPING = "ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_ELEMENT_COLLECTION_MAPPING";
		211	public static final String ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_PROHIBITED_RELATIONSHIP_MAPPING = "ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_PROHIBITED_RELATIONSHIP_MAPPING";
210	public static final String VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST = "VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST";	212	public static final String VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST = "VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST";
211	public static final String VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED = "VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED";	213	public static final String VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED = "VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED";
212	public static final String ELEMENT_COLLECTION_MAP_KEY_CLASS_NOT_DEFINED = "ELEMENT_COLLECTION_MAP_KEY_CLASS_NOT_DEFINED";	214	public static final String ELEMENT_COLLECTION_MAP_KEY_CLASS_NOT_DEFINED = "ELEMENT_COLLECTION_MAP_KEY_CLASS_NOT_DEFINED";

Return to bug 325162

Lines 29-40 Link Here

(-)src/org/eclipse/jpt/jpa/core/internal/jpa2/context/java/AbstractJavaElementCollectionMapping2_0.java (+93 lines)
29	import org.eclipse.jpt.common.utility.internal.iterators.FilteringIterator;	29	import org.eclipse.jpt.common.utility.internal.iterators.FilteringIterator;
30	import org.eclipse.jpt.common.utility.internal.iterators.TransformationIterator;	30	import org.eclipse.jpt.common.utility.internal.iterators.TransformationIterator;
31	import org.eclipse.jpt.jpa.core.JpaFactory;	31	import org.eclipse.jpt.jpa.core.JpaFactory;
		32	import org.eclipse.jpt.jpa.core.MappingKeys;
32	import org.eclipse.jpt.jpa.core.context.AssociationOverride;	33	import org.eclipse.jpt.jpa.core.context.AssociationOverride;
33	import org.eclipse.jpt.jpa.core.context.AssociationOverrideContainer;	34	import org.eclipse.jpt.jpa.core.context.AssociationOverrideContainer;
34	import org.eclipse.jpt.jpa.core.context.AttributeMapping;	35	import org.eclipse.jpt.jpa.core.context.AttributeMapping;
35	import org.eclipse.jpt.jpa.core.context.AttributeOverride;	36	import org.eclipse.jpt.jpa.core.context.AttributeOverride;
36	import org.eclipse.jpt.jpa.core.context.AttributeOverrideContainer;	37	import org.eclipse.jpt.jpa.core.context.AttributeOverrideContainer;
37	import org.eclipse.jpt.jpa.core.context.BaseColumn;	38	import org.eclipse.jpt.jpa.core.context.BaseColumn;
		39	import org.eclipse.jpt.jpa.core.context.BaseEmbeddedMapping;
38	import org.eclipse.jpt.jpa.core.context.Column;	40	import org.eclipse.jpt.jpa.core.context.Column;
39	import org.eclipse.jpt.jpa.core.context.Converter;	41	import org.eclipse.jpt.jpa.core.context.Converter;
40	import org.eclipse.jpt.jpa.core.context.Embeddable;	42	import org.eclipse.jpt.jpa.core.context.Embeddable;
Lines 47-52 Link Here
47	import org.eclipse.jpt.jpa.core.context.Override_;	49	import org.eclipse.jpt.jpa.core.context.Override_;
48	import org.eclipse.jpt.jpa.core.context.PersistentType;	50	import org.eclipse.jpt.jpa.core.context.PersistentType;
49	import org.eclipse.jpt.jpa.core.context.Relationship;	51	import org.eclipse.jpt.jpa.core.context.Relationship;
		52	import org.eclipse.jpt.jpa.core.context.RelationshipMapping;
50	import org.eclipse.jpt.jpa.core.context.Table;	53	import org.eclipse.jpt.jpa.core.context.Table;
51	import org.eclipse.jpt.jpa.core.context.TypeMapping;	54	import org.eclipse.jpt.jpa.core.context.TypeMapping;
52	import org.eclipse.jpt.jpa.core.context.java.JavaAssociationOverrideContainer;	55	import org.eclipse.jpt.jpa.core.context.java.JavaAssociationOverrideContainer;
Lines 1156-1161 Link Here
1156	this.collectionTable.validate(messages, reporter, astRoot);	1159	this.collectionTable.validate(messages, reporter, astRoot);
1157	this.validateValue(messages, reporter, astRoot);	1160	this.validateValue(messages, reporter, astRoot);
1158	this.validateMapKey(messages, reporter, astRoot);	1161	this.validateMapKey(messages, reporter, astRoot);
		1162	this.validateNoEmbeddableInMappingContainsProhibittedMapping(messages, astRoot);
		1163	}
		1164
		1165	protected void validateNoEmbeddableInMappingContainsProhibittedMapping(List<IMessage> messages, CompilationUnit astRoot) {
		1166	Embeddable embeddableClass = getResolvedTargetEmbeddable();
		1167	if (embeddableClass != null) {
		1168	embeddableContainsElementCollection(messages, astRoot, embeddableClass);
		1169	embeddableContainsProhibitedRelationshipMapping(messages, astRoot, embeddableClass);
		1170	embeddableHierarchyContainsProhibittedMapping(messages, astRoot, embeddableClass, new ArrayList<Embeddable>());
		1171	}
		1172	embeddableClass = getResolvedMapKeyEmbeddable();
		1173	if (embeddableClass != null) {
		1174	embeddableContainsElementCollection(messages, astRoot, embeddableClass);
		1175	embeddableContainsProhibitedRelationshipMapping(messages, astRoot, embeddableClass);
		1176	embeddableHierarchyContainsProhibittedMapping(messages, astRoot, embeddableClass, new ArrayList<Embeddable>());
		1177	}
		1178	}
		1179
		1180	private void embeddableHierarchyContainsProhibittedMapping(List<IMessage> messages, CompilationUnit astRoot, Embeddable parentEmbeddable, List<Embeddable> visited) {
		1181	Iterable<AttributeMapping> embeddedIterable = parentEmbeddable.getAllAttributeMappings(MappingKeys.EMBEDDED_ATTRIBUTE_MAPPING_KEY);
		1182	for(AttributeMapping mapping : embeddedIterable) {
		1183	Embeddable embeddable = ((BaseEmbeddedMapping)mapping).getTargetEmbeddable();
		1184	if (embeddable != null && embeddable != parentEmbeddable) {
		1185	embeddableContainsElementCollection(messages, astRoot, embeddable);
		1186	embeddableContainsProhibitedRelationshipMapping(messages, astRoot, embeddable);
		1187	if (!CollectionTools.contains(visited, embeddable)) {
		1188	visited.add(embeddable);
		1189	embeddableHierarchyContainsProhibittedMapping(messages, astRoot, embeddable, visited);
		1190	}
		1191	}
		1192	}
		1193	Iterable<AttributeMapping> embeddedIdIterable = parentEmbeddable.getAllAttributeMappings(MappingKeys.EMBEDDED_ID_ATTRIBUTE_MAPPING_KEY);
		1194	for(AttributeMapping mapping : embeddedIdIterable) {
		1195	Embeddable embeddable = ((BaseEmbeddedMapping)mapping).getTargetEmbeddable();
		1196	if (embeddable != null && embeddable != parentEmbeddable) {
		1197	embeddableContainsElementCollection(messages, astRoot, embeddable);
		1198	embeddableContainsProhibitedRelationshipMapping(messages, astRoot, embeddable);
		1199	if (!CollectionTools.contains(visited, embeddable)) {
		1200	visited.add(embeddable);
		1201	embeddableHierarchyContainsProhibittedMapping(messages, astRoot, embeddable, visited);
		1202	}
		1203	}
		1204	}
		1205	}
		1206
		1207	private void embeddableContainsProhibitedRelationshipMapping(List<IMessage> messages, CompilationUnit astRoot, Embeddable embeddable) {
		1208	boolean prohibitedMappingFound = false;
		1209	Iterable<AttributeMapping> manyToManyMappings = embeddable.getAllAttributeMappings(MappingKeys.MANY_TO_MANY_ATTRIBUTE_MAPPING_KEY);
		1210	Iterable<AttributeMapping> oneToManyMappings = embeddable.getAllAttributeMappings(MappingKeys.ONE_TO_MANY_ATTRIBUTE_MAPPING_KEY);
		1211	if (oneToManyMappings.iterator().hasNext() \|\| manyToManyMappings.iterator().hasNext()) {
		1212	prohibitedMappingFound = true;
		1213	}
		1214	Iterable<AttributeMapping> manyToOneMappings = embeddable.getAllAttributeMappings(MappingKeys.MANY_TO_ONE_ATTRIBUTE_MAPPING_KEY);
		1215	if (manyToOneMappings.iterator().hasNext()) {
		1216	if (((RelationshipMapping)manyToOneMappings.iterator().next()).getRelationshipOwner() != null) {
		1217	prohibitedMappingFound = true;
		1218	}
		1219	}
		1220	Iterable<AttributeMapping> oneToOneMappings = embeddable.getAllAttributeMappings(MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY);
		1221	if (oneToOneMappings.iterator().hasNext()) {
		1222	if (((RelationshipMapping)oneToOneMappings.iterator().next()).getRelationshipOwner() != null) {
		1223	prohibitedMappingFound = true;
		1224	}
		1225	}
1226	if (prohibitedMappingFound) {
1227	messages.add(
1228	DefaultJpaValidationMessages.buildMessage(
1229	IMessage.HIGH_SEVERITY,
1230	JpaValidationMessages.ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_PROHIBITED_RELATIONSHIP_MAPPING,
1231	new String[] {embeddable.getName()},
1232	this,
1233	this.getValidationTextRange(astRoot)
1234	)
1235	);
1236	}
1237	}
1238
1239	private void embeddableContainsElementCollection(List<IMessage> messages, CompilationUnit astRoot, Embeddable embeddable) {
1240	Iterable<AttributeMapping> elementCollectionMappings = embeddable.getAllAttributeMappings(MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
1241	if (elementCollectionMappings.iterator().hasNext()) {
1242	messages.add(
1243	DefaultJpaValidationMessages.buildMessage(
1244	IMessage.HIGH_SEVERITY,
1245	JpaValidationMessages.ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_ELEMENT_COLLECTION_MAPPING,
1246	new String[] {embeddable.getName()},
1247	this,
1248	this.getValidationTextRange(astRoot)
1249	)
1250	);
1251	}
1159	}	1252	}
1160		1253
1161	protected void validateTargetClass(List<IMessage> messages, CompilationUnit astRoot) {	1254	protected void validateTargetClass(List<IMessage> messages, CompilationUnit astRoot) {

Lines 12-17 Link Here

(-)src/org/eclipse/jpt/jpa/core/internal/jpa2/context/orm/AbstractOrmElementCollectionMapping2_0.java (+94 lines)
12	import java.util.ArrayList;	12	import java.util.ArrayList;
13	import java.util.Iterator;	13	import java.util.Iterator;
14	import java.util.List;	14	import java.util.List;
		15
15	import org.eclipse.emf.common.util.EList;	16	import org.eclipse.emf.common.util.EList;
16	import org.eclipse.jdt.core.IJavaProject;	17	import org.eclipse.jdt.core.IJavaProject;
17	import org.eclipse.jdt.core.IPackageFragment;	18	import org.eclipse.jdt.core.IPackageFragment;
Lines 29-40 Link Here
29	import org.eclipse.jpt.common.utility.internal.iterators.CompositeIterator;	30	import org.eclipse.jpt.common.utility.internal.iterators.CompositeIterator;
30	import org.eclipse.jpt.common.utility.internal.iterators.EmptyIterator;	31	import org.eclipse.jpt.common.utility.internal.iterators.EmptyIterator;
31	import org.eclipse.jpt.common.utility.internal.iterators.TransformationIterator;	32	import org.eclipse.jpt.common.utility.internal.iterators.TransformationIterator;
		33	import org.eclipse.jpt.jpa.core.MappingKeys;
32	import org.eclipse.jpt.jpa.core.context.AssociationOverride;	34	import org.eclipse.jpt.jpa.core.context.AssociationOverride;
33	import org.eclipse.jpt.jpa.core.context.AssociationOverrideContainer;	35	import org.eclipse.jpt.jpa.core.context.AssociationOverrideContainer;
34	import org.eclipse.jpt.jpa.core.context.AttributeMapping;	36	import org.eclipse.jpt.jpa.core.context.AttributeMapping;
35	import org.eclipse.jpt.jpa.core.context.AttributeOverride;	37	import org.eclipse.jpt.jpa.core.context.AttributeOverride;
36	import org.eclipse.jpt.jpa.core.context.AttributeOverrideContainer;	38	import org.eclipse.jpt.jpa.core.context.AttributeOverrideContainer;
37	import org.eclipse.jpt.jpa.core.context.BaseColumn;	39	import org.eclipse.jpt.jpa.core.context.BaseColumn;
		40	import org.eclipse.jpt.jpa.core.context.BaseEmbeddedMapping;
38	import org.eclipse.jpt.jpa.core.context.Column;	41	import org.eclipse.jpt.jpa.core.context.Column;
39	import org.eclipse.jpt.jpa.core.context.Converter;	42	import org.eclipse.jpt.jpa.core.context.Converter;
40	import org.eclipse.jpt.jpa.core.context.Embeddable;	43	import org.eclipse.jpt.jpa.core.context.Embeddable;
Lines 47-52 Link Here
47	import org.eclipse.jpt.jpa.core.context.Override_;	50	import org.eclipse.jpt.jpa.core.context.Override_;
48	import org.eclipse.jpt.jpa.core.context.PersistentType;	51	import org.eclipse.jpt.jpa.core.context.PersistentType;
49	import org.eclipse.jpt.jpa.core.context.Relationship;	52	import org.eclipse.jpt.jpa.core.context.Relationship;
		53	import org.eclipse.jpt.jpa.core.context.RelationshipMapping;
50	import org.eclipse.jpt.jpa.core.context.Table;	54	import org.eclipse.jpt.jpa.core.context.Table;
51	import org.eclipse.jpt.jpa.core.context.TypeMapping;	55	import org.eclipse.jpt.jpa.core.context.TypeMapping;
52	import org.eclipse.jpt.jpa.core.context.java.JavaAssociationOverride;	56	import org.eclipse.jpt.jpa.core.context.java.JavaAssociationOverride;
Lines 1214-1219 Link Here
1214	this.collectionTable.validate(messages, reporter);	1218	this.collectionTable.validate(messages, reporter);
1215	this.validateValue(messages, reporter);	1219	this.validateValue(messages, reporter);
1216	this.validateMapKey(messages, reporter);	1220	this.validateMapKey(messages, reporter);
		1221	this.validateNoEmbeddableInMappingContainsProhibittedMapping(messages);
		1222	}
		1223
		1224	protected void validateNoEmbeddableInMappingContainsProhibittedMapping(List<IMessage> messages) {
		1225	Embeddable embeddableClass = getResolvedTargetEmbeddable();
		1226	if (embeddableClass != null) {
		1227	embeddableContainsElementCollection(messages, embeddableClass);
		1228	embeddableContainsProhibitedRelationshipMapping(messages, embeddableClass);
		1229	embeddableHierarchyContainsProhibittedMapping(messages, embeddableClass, new ArrayList<Embeddable>());
		1230	}
		1231	embeddableClass = getResolvedMapKeyEmbeddable();
		1232	if (embeddableClass != null) {
		1233	embeddableContainsElementCollection(messages, embeddableClass);
		1234	embeddableContainsProhibitedRelationshipMapping(messages, embeddableClass);
		1235	embeddableHierarchyContainsProhibittedMapping(messages, embeddableClass, new ArrayList<Embeddable>());
		1236	}
		1237	}
		1238
		1239	private void embeddableHierarchyContainsProhibittedMapping(List<IMessage> messages, Embeddable parentEmbeddable, List<Embeddable> visited) {
		1240	Iterable<AttributeMapping> embeddedIterable = parentEmbeddable.getAllAttributeMappings(MappingKeys.EMBEDDED_ATTRIBUTE_MAPPING_KEY);
		1241	for(AttributeMapping mapping : embeddedIterable) {
		1242	Embeddable embeddable = ((BaseEmbeddedMapping)mapping).getTargetEmbeddable();
		1243	if (embeddable != null && embeddable != parentEmbeddable) {
		1244	embeddableContainsElementCollection(messages, embeddable);
		1245	embeddableContainsProhibitedRelationshipMapping(messages, embeddable);
		1246	if (!CollectionTools.contains(visited, embeddable)) {
		1247	visited.add(embeddable);
		1248	embeddableHierarchyContainsProhibittedMapping(messages, embeddable, visited);
		1249	}
		1250	}
		1251	}
		1252	Iterable<AttributeMapping> embeddedIdIterable = parentEmbeddable.getAllAttributeMappings(MappingKeys.EMBEDDED_ID_ATTRIBUTE_MAPPING_KEY);
		1253	for(AttributeMapping mapping : embeddedIdIterable) {
		1254	Embeddable embeddable = ((BaseEmbeddedMapping)mapping).getTargetEmbeddable();
		1255	if (embeddable != null && embeddable != parentEmbeddable) {
		1256	embeddableContainsElementCollection(messages, embeddable);
		1257	embeddableContainsProhibitedRelationshipMapping(messages, embeddable);
		1258	if (!CollectionTools.contains(visited, embeddable)) {
		1259	visited.add(embeddable);
		1260	embeddableHierarchyContainsProhibittedMapping(messages, embeddable, visited);
		1261	}
		1262	}
		1263	}
		1264	}
		1265
		1266	private void embeddableContainsProhibitedRelationshipMapping(List<IMessage> messages, Embeddable embeddable) {
		1267	boolean prohibitedMappingFound = false;
		1268	Iterable<AttributeMapping> manyToManyMappings = embeddable.getAllAttributeMappings(MappingKeys.MANY_TO_MANY_ATTRIBUTE_MAPPING_KEY);
		1269	Iterable<AttributeMapping> oneToManyMappings = embeddable.getAllAttributeMappings(MappingKeys.ONE_TO_MANY_ATTRIBUTE_MAPPING_KEY);
		1270	if (oneToManyMappings.iterator().hasNext() \|\| manyToManyMappings.iterator().hasNext()) {
		1271	prohibitedMappingFound = true;
		1272	}
		1273	Iterable<AttributeMapping> manyToOneMappings = embeddable.getAllAttributeMappings(MappingKeys.MANY_TO_ONE_ATTRIBUTE_MAPPING_KEY);
		1274	if (manyToOneMappings.iterator().hasNext()) {
		1275	if (((RelationshipMapping)manyToOneMappings.iterator().next()).getRelationshipOwner() != null) {
		1276	prohibitedMappingFound = true;
		1277	}
		1278	}
		1279	Iterable<AttributeMapping> oneToOneMappings = embeddable.getAllAttributeMappings(MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY);
		1280	if (oneToOneMappings.iterator().hasNext()) {
		1281	if (((RelationshipMapping)oneToOneMappings.iterator().next()).getRelationshipOwner() != null) {
		1282	prohibitedMappingFound = true;
		1283	}
		1284	}
1285	if (prohibitedMappingFound) {
1286	messages.add(
1287	DefaultJpaValidationMessages.buildMessage(
1288	IMessage.HIGH_SEVERITY,
1289	JpaValidationMessages.ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_PROHIBITED_RELATIONSHIP_MAPPING,
1290	new String[] {embeddable.getName()},
1291	this,
1292	this.getValidationTextRange()
1293	)
1294	);
1295	}
1296	}
1297
1298	private void embeddableContainsElementCollection(List<IMessage> messages, Embeddable embeddable) {
1299	Iterable<AttributeMapping> elementCollectionMappings = embeddable.getAllAttributeMappings(MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
1300	if (elementCollectionMappings.iterator().hasNext()) {
1301	messages.add(
1302	DefaultJpaValidationMessages.buildMessage(
1303	IMessage.HIGH_SEVERITY,
1304	JpaValidationMessages.ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_ELEMENT_COLLECTION_MAPPING,
1305	new String[] {embeddable.getName()},
1306	this,
1307	this.getValidationTextRange()
1308	)
1309	);
1310	}
1217	}	1311	}
1218		1312
1219	protected void validateTargetClass(List<IMessage> messages) {	1313	protected void validateTargetClass(List<IMessage> messages) {