Attachment #190194 for bug #325162

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

Lines 184-189 Link Here

(-)property_files/jpa_validation.properties (+2 lines)
184	VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_MAP_KEY_CLASS_NOT_DEFINED=In implied attribute \"{0}\", map key class is not defined	184	VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_MAP_KEY_CLASS_NOT_DEFINED=In implied attribute \"{0}\", map key class is not defined
185	ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE=Target class \"{0}\" is not an embeddable or basic type	185	ELEMENT_COLLECTION_TARGET_CLASS_MUST_BE_EMBEDDABLE_OR_BASIC_TYPE=Target class \"{0}\" is not an embeddable or basic type
186	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	186	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	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.
		188	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.
187	MAP_KEY_COLUMN_UNRESOLVED_NAME = Map key column \"{0}\" cannot be resolved on table \"{1}\"	189	MAP_KEY_COLUMN_UNRESOLVED_NAME = Map key column \"{0}\" cannot be resolved on table \"{1}\"
188	VIRTUAL_ATTRIBUTE_MAP_KEY_COLUMN_UNRESOLVED_NAME = In implied attribute \"{0}\", map key column \"{1}\" cannot be resolved on table \"{2}\"	190	VIRTUAL_ATTRIBUTE_MAP_KEY_COLUMN_UNRESOLVED_NAME = In implied attribute \"{0}\", map key column \"{1}\" cannot be resolved on table \"{2}\"
189	COLLECTION_TABLE_UNRESOLVED_CATALOG = Catalog \"{0}\" cannot be resolved for collection table \"{1}\"	191	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>());
		}
	}
		
	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>());
		}
	}

	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 206-211 Link Here

(-)src/org/eclipse/jpt/jpa/core/internal/validation/JpaValidationMessages.java (+2 lines)
206	public static final String ORDER_COLUMN_AND_ORDER_BY_BOTH_SPECIFIED = "ORDER_COLUMN_AND_ORDER_BY_BOTH_SPECIFIED";	206	public static final String ORDER_COLUMN_AND_ORDER_BY_BOTH_SPECIFIED = "ORDER_COLUMN_AND_ORDER_BY_BOTH_SPECIFIED";
207	public static final String ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED = "ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED";	207	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_DOES_NOT_EXIST = "ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST";	208	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_CONTAINS_EMBEDDABLE_WITH_ELEMENT_COLLECTION_MAPPING = "ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_ELEMENT_COLLECTION_MAPPING";
		210	public static final String ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_PROHIBITED_RELATIONSHIP_MAPPING = "ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_PROHIBITED_RELATIONSHIP_MAPPING";
209	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_DOES_NOT_EXIST = "VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_DOES_NOT_EXIST";
210	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 VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED = "VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_TARGET_CLASS_NOT_DEFINED";
211	public static final String ELEMENT_COLLECTION_MAP_KEY_CLASS_NOT_DEFINED = "ELEMENT_COLLECTION_MAP_KEY_CLASS_NOT_DEFINED";	213	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 (+87 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	}
		1173
		1174	private void embeddableHierarchyContainsProhibittedMapping(List<IMessage> messages, CompilationUnit astRoot, Embeddable parentEmbeddable, List<Embeddable> visited) {
		1175	Iterable<AttributeMapping> embeddedIterable = parentEmbeddable.getAllAttributeMappings(MappingKeys.EMBEDDED_ATTRIBUTE_MAPPING_KEY);
		1176	for(AttributeMapping mapping : embeddedIterable) {
		1177	Embeddable embeddable = ((BaseEmbeddedMapping)mapping).getTargetEmbeddable();
		1178	if (embeddable != null && embeddable != parentEmbeddable) {
		1179	embeddableContainsElementCollection(messages, astRoot, embeddable);
		1180	embeddableContainsProhibitedRelationshipMapping(messages, astRoot, embeddable);
		1181	if (!CollectionTools.contains(visited, embeddable)) {
		1182	visited.add(embeddable);
		1183	embeddableHierarchyContainsProhibittedMapping(messages, astRoot, embeddable, visited);
		1184	}
		1185	}
		1186	}
		1187	Iterable<AttributeMapping> embeddedIdIterable = parentEmbeddable.getAllAttributeMappings(MappingKeys.EMBEDDED_ID_ATTRIBUTE_MAPPING_KEY);
		1188	for(AttributeMapping mapping : embeddedIdIterable) {
		1189	Embeddable embeddable = ((BaseEmbeddedMapping)mapping).getTargetEmbeddable();
		1190	if (embeddable != null && embeddable != parentEmbeddable) {
		1191	embeddableContainsElementCollection(messages, astRoot, embeddable);
		1192	embeddableContainsProhibitedRelationshipMapping(messages, astRoot, embeddable);
		1193	if (!CollectionTools.contains(visited, embeddable)) {
		1194	visited.add(embeddable);
		1195	embeddableHierarchyContainsProhibittedMapping(messages, astRoot, embeddable, visited);
		1196	}
		1197	}
		1198	}
		1199	}
		1200
		1201	private void embeddableContainsProhibitedRelationshipMapping(List<IMessage> messages, CompilationUnit astRoot, Embeddable embeddable) {
		1202	boolean prohibitedMappingFound = false;
		1203	Iterable<AttributeMapping> manyToManyMappings = embeddable.getAllAttributeMappings(MappingKeys.MANY_TO_MANY_ATTRIBUTE_MAPPING_KEY);
		1204	Iterable<AttributeMapping> oneToManyMappings = embeddable.getAllAttributeMappings(MappingKeys.ONE_TO_MANY_ATTRIBUTE_MAPPING_KEY);
		1205	if (oneToManyMappings.iterator().hasNext() \|\| manyToManyMappings.iterator().hasNext()) {
		1206	prohibitedMappingFound = true;
		1207	}
		1208	Iterable<AttributeMapping> manyToOneMappings = embeddable.getAllAttributeMappings(MappingKeys.MANY_TO_ONE_ATTRIBUTE_MAPPING_KEY);
		1209	if (manyToOneMappings.iterator().hasNext()) {
		1210	if (((RelationshipMapping)manyToOneMappings.iterator().next()).getRelationshipOwner() != null) {
		1211	prohibitedMappingFound = true;
		1212	}
		1213	}
		1214	Iterable<AttributeMapping> oneToOneMappings = embeddable.getAllAttributeMappings(MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY);
		1215	if (oneToOneMappings.iterator().hasNext()) {
		1216	if (((RelationshipMapping)oneToOneMappings.iterator().next()).getRelationshipOwner() != null) {
		1217	prohibitedMappingFound = true;
		1218	}
		1219	}
		1220	if (prohibitedMappingFound) {
		1221	messages.add(
		1222	DefaultJpaValidationMessages.buildMessage(
		1223	IMessage.HIGH_SEVERITY,
		1224	JpaValidationMessages.ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_PROHIBITED_RELATIONSHIP_MAPPING,
		1225	new String[] {embeddable.getName()},
1226	this,
1227	this.getValidationTextRange(astRoot)
1228	)
1229	);
1230	}
1231	}
1232
1233	private void embeddableContainsElementCollection(List<IMessage> messages, CompilationUnit astRoot, Embeddable embeddable) {
1234	Iterable<AttributeMapping> elementCollectionMappings = embeddable.getAllAttributeMappings(MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
1235	if (elementCollectionMappings.iterator().hasNext()) {
1236	messages.add(
1237	DefaultJpaValidationMessages.buildMessage(
1238	IMessage.HIGH_SEVERITY,
1239	JpaValidationMessages.ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_ELEMENT_COLLECTION_MAPPING,
1240	new String[] {embeddable.getName()},
1241	this,
1242	this.getValidationTextRange(astRoot)
1243	)
1244	);
1245	}
1159	}	1246	}
1160		1247
1161	protected void validateTargetClass(List<IMessage> messages, CompilationUnit astRoot) {	1248	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 (+88 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	}
		1232
		1233	private void embeddableHierarchyContainsProhibittedMapping(List<IMessage> messages, Embeddable parentEmbeddable, List<Embeddable> visited) {
		1234	Iterable<AttributeMapping> embeddedIterable = parentEmbeddable.getAllAttributeMappings(MappingKeys.EMBEDDED_ATTRIBUTE_MAPPING_KEY);
		1235	for(AttributeMapping mapping : embeddedIterable) {
		1236	Embeddable embeddable = ((BaseEmbeddedMapping)mapping).getTargetEmbeddable();
		1237	if (embeddable != null && embeddable != parentEmbeddable) {
		1238	embeddableContainsElementCollection(messages, embeddable);
		1239	embeddableContainsProhibitedRelationshipMapping(messages, embeddable);
		1240	if (!CollectionTools.contains(visited, embeddable)) {
		1241	visited.add(embeddable);
		1242	embeddableHierarchyContainsProhibittedMapping(messages, embeddable, visited);
		1243	}
		1244	}
		1245	}
		1246	Iterable<AttributeMapping> embeddedIdIterable = parentEmbeddable.getAllAttributeMappings(MappingKeys.EMBEDDED_ID_ATTRIBUTE_MAPPING_KEY);
		1247	for(AttributeMapping mapping : embeddedIdIterable) {
		1248	Embeddable embeddable = ((BaseEmbeddedMapping)mapping).getTargetEmbeddable();
		1249	if (embeddable != null && embeddable != parentEmbeddable) {
		1250	embeddableContainsElementCollection(messages, embeddable);
		1251	embeddableContainsProhibitedRelationshipMapping(messages, embeddable);
		1252	if (!CollectionTools.contains(visited, embeddable)) {
		1253	visited.add(embeddable);
		1254	embeddableHierarchyContainsProhibittedMapping(messages, embeddable, visited);
		1255	}
		1256	}
		1257	}
		1258	}
		1259
		1260	private void embeddableContainsProhibitedRelationshipMapping(List<IMessage> messages, Embeddable embeddable) {
		1261	boolean prohibitedMappingFound = false;
		1262	Iterable<AttributeMapping> manyToManyMappings = embeddable.getAllAttributeMappings(MappingKeys.MANY_TO_MANY_ATTRIBUTE_MAPPING_KEY);
		1263	Iterable<AttributeMapping> oneToManyMappings = embeddable.getAllAttributeMappings(MappingKeys.ONE_TO_MANY_ATTRIBUTE_MAPPING_KEY);
		1264	if (oneToManyMappings.iterator().hasNext() \|\| manyToManyMappings.iterator().hasNext()) {
		1265	prohibitedMappingFound = true;
		1266	}
		1267	Iterable<AttributeMapping> manyToOneMappings = embeddable.getAllAttributeMappings(MappingKeys.MANY_TO_ONE_ATTRIBUTE_MAPPING_KEY);
		1268	if (manyToOneMappings.iterator().hasNext()) {
		1269	if (((RelationshipMapping)manyToOneMappings.iterator().next()).getRelationshipOwner() != null) {
		1270	prohibitedMappingFound = true;
		1271	}
		1272	}
		1273	Iterable<AttributeMapping> oneToOneMappings = embeddable.getAllAttributeMappings(MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY);
		1274	if (oneToOneMappings.iterator().hasNext()) {
		1275	if (((RelationshipMapping)oneToOneMappings.iterator().next()).getRelationshipOwner() != null) {
		1276	prohibitedMappingFound = true;
		1277	}
		1278	}
		1279	if (prohibitedMappingFound) {
		1280	messages.add(
		1281	DefaultJpaValidationMessages.buildMessage(
		1282	IMessage.HIGH_SEVERITY,
		1283	JpaValidationMessages.ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_PROHIBITED_RELATIONSHIP_MAPPING,
		1284	new String[] {embeddable.getName()},
1285	this,
1286	this.getValidationTextRange()
1287	)
1288	);
1289	}
1290	}
1291
1292	private void embeddableContainsElementCollection(List<IMessage> messages, Embeddable embeddable) {
1293	Iterable<AttributeMapping> elementCollectionMappings = embeddable.getAllAttributeMappings(MappingKeys2_0.ELEMENT_COLLECTION_ATTRIBUTE_MAPPING_KEY);
1294	if (elementCollectionMappings.iterator().hasNext()) {
1295	messages.add(
1296	DefaultJpaValidationMessages.buildMessage(
1297	IMessage.HIGH_SEVERITY,
1298	JpaValidationMessages.ELEMENT_COLLECTION_CONTAINS_EMBEDDABLE_WITH_ELEMENT_COLLECTION_MAPPING,
1299	new String[] {embeddable.getName()},
1300	this,
1301	this.getValidationTextRange()
1302	)
1303	);
1304	}
1217	}	1305	}
1218		1306
1219	protected void validateTargetClass(List<IMessage> messages) {	1307	protected void validateTargetClass(List<IMessage> messages) {