Attachment #162793 for bug #306777

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

View | Details | Raw Unified | Return to bug 306777
Collapse All | Expand All




import org.eclipse.jpt.ui.details.JpaComposite;
import org.eclipse.jpt.ui.internal.details.AbstractIdMappingComposite;
import org.eclipse.jpt.ui.internal.details.ColumnComposite;
import org.eclipse.jpt.ui.internal.details.IdMappingGenerationComposite;
import org.eclipse.jpt.ui.internal.details.JptUiDetailsMessages;
import org.eclipse.jpt.ui.internal.details.TemporalTypeComposite;
import org.eclipse.jpt.ui.internal.widgets.Pane;

import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;

public class EclipseLinkIdMappingComposite<T extends IdMapping>
	extends AbstractIdMappingComposite<T>
	implements JpaComposite
 * -----------------------------------------------------------------------------
 * | ------------------------------------------------------------------------- |
 * | |                                                                       | |
 * | | ColumnComposite                                                       | |
 * | |                                                                       | |
 * | ------------------------------------------------------------------------- |
 * | ------------------------------------------------------------------------- |
 * | |                                                                       | |
 * | | TemporalTypeComposite                                                 | |
 * | |                                                                       | |
 * | ------------------------------------------------------------------------- |
 * | ------------------------------------------------------------------------- |
 * | |                                                                       | |
 * | | GenerationComposite                                                   | |
 * | |                                                                       | |
 * | ------------------------------------------------------------------------- |
 * -----------------------------------------------------------------------------</pre>
 *
 * @see IdMapping
 * @see ColumnComposite
 * @see TemporalTypeComposite
 * @see IdMappingGenerationComposite
 *
 * @version 2.3
 * @since 2.1
 */
public class EclipseLinkIdMappingComposite<T extends IdMapping> extends AbstractIdMappingComposite<T>
                                implements JpaComposite
{
	public EclipseLinkIdMappingComposite(
			PropertyValueModel<? extends T> subjectHolder,
	        Composite parent,
	        WidgetFactory widgetFactory) {
		
	 * @param widgetFactory The factory used to create various common widgets
	 */
	public EclipseLinkIdMappingComposite(PropertyValueModel<? extends T> subjectHolder,
	                          Composite parent,
	                          WidgetFactory widgetFactory) {

		super(subjectHolder, parent, widgetFactory);
	}
	
	
	@Override
	protected void initializeIdSection(Composite container) {
		new ColumnComposite(this, buildColumnHolder(), container);

	@Override
	protected void initializeTypeSection(Composite container) {
		((GridLayout) container.getLayout()).numColumns = 2;
		
		// No converter
		Button noConverterButton = addRadioButton(
			container, 

			buildConverterBooleanHolder(EclipseLinkConvert.ECLIPSE_LINK_CONVERTER), 
			null);
		((GridData) elConverterButton.getLayoutData()).horizontalSpan = 2;
		
		Pane<EclipseLinkConvert> convertComposite = buildConvertComposite(buildEclipseLinkConverterHolder(converterHolder), container);
		GridData gridData = (GridData) convertComposite.getControl().getLayoutData();
		gridData.horizontalSpan = 2;
		gridData.horizontalIndent = 20;
		registerSubPane(convertComposite);
	}
	
	protected Pane<EclipseLinkConvert> buildConvertComposite(PropertyValueModel<EclipseLinkConvert> convertHolder, Composite container) {
		return new EclipseLinkConvertComposite(convertHolder, container, getWidgetFactory());
	}
	
	protected PropertyValueModel<EclipseLinkConvert> buildEclipseLinkConverterHolder(PropertyValueModel<Converter> converterHolder) {
		return new TransformationPropertyValueModel<Converter, EclipseLinkConvert>(converterHolder) {
			@Override

			}
		};
	}
	
	protected PropertyValueModel<EclipseLinkMutable> buildMutableHolder() {
		return new PropertyAspectAdapter<T, EclipseLinkMutable>(getSubjectHolder()) {
			@Override

			}
		};
	}
}




*******************************************************************************/
package org.eclipse.jpt.eclipselink.ui.internal.v2_0.details.java;

import org.eclipse.jpt.core.context.java.JavaEmbeddedIdMapping;
import org.eclipse.jpt.core.context.java.JavaEntity;
import org.eclipse.jpt.core.context.java.JavaIdMapping;
import org.eclipse.jpt.core.context.java.JavaManyToManyMapping;

import org.eclipse.jpt.ui.WidgetFactory;
import org.eclipse.jpt.ui.details.JpaComposite;
import org.eclipse.jpt.ui.internal.jpa2.details.ElementCollectionMapping2_0Composite;
import org.eclipse.jpt.ui.internal.jpa2.details.EmbeddedIdMapping2_0Composite;
import org.eclipse.jpt.ui.jpa2.details.java.JavaUiFactory2_0;
import org.eclipse.jpt.utility.model.value.PropertyValueModel;
import org.eclipse.swt.widgets.Composite;

	public EclipseLink2_0JavaUiFactory() {
		super();
	}
	
	
	// **************** java type mapping composites ***************************
	

		return new JavaEclipseLinkMappedSuperclass2_0Composite(subjectHolder, parent, widgetFactory);
	}
	
	
	// **************** java attribute mapping composites **********************
	
	@Override
	public JpaComposite createJavaIdMappingComposite(
			PropertyValueModel<JavaIdMapping> subjectHolder,

		return new JavaEclipseLinkIdMapping2_0Composite(subjectHolder, parent, widgetFactory);
	}
	
	@Override
	public JpaComposite createJavaEmbeddedIdMappingComposite(
			PropertyValueModel<JavaEmbeddedIdMapping> subjectHolder, 
			Composite parent, 
			WidgetFactory widgetFactory) {
		return new EmbeddedIdMapping2_0Composite(subjectHolder, parent, widgetFactory);
	}
	
	public JpaComposite createJavaElementCollectionMapping2_0Composite(
			PropertyValueModel<JavaElementCollectionMapping2_0> subjectHolder,
			Composite parent,

			WidgetFactory widgetFactory) {
		return new JavaEclipseLinkManyToManyMapping2_0Composite(subjectHolder, parent, widgetFactory);
	}

}




 ******************************************************************************/
package org.eclipse.jpt.eclipselink.ui.internal.v2_0.details.java;

import org.eclipse.jpt.core.context.IdMapping;
import org.eclipse.jpt.core.context.java.JavaIdMapping;
import org.eclipse.jpt.eclipselink.ui.internal.details.EclipseLinkIdMappingComposite;
import org.eclipse.jpt.eclipselink.ui.internal.details.EclipseLinkMutableComposite;
import org.eclipse.jpt.ui.WidgetFactory;
import org.eclipse.jpt.ui.details.JpaComposite;
import org.eclipse.jpt.ui.internal.details.ColumnComposite;
import org.eclipse.jpt.ui.internal.jpa2.details.IdMapping2_0MappedByRelationshipPane;
import org.eclipse.jpt.ui.internal.details.TemporalTypeComposite;
import org.eclipse.jpt.ui.internal.jpa2.details.IdMappingGeneration2_0Composite;
import org.eclipse.jpt.utility.model.value.PropertyValueModel;
import org.eclipse.swt.widgets.Composite;

public class JavaEclipseLinkIdMapping2_0Composite
	extends EclipseLinkIdMappingComposite<JavaIdMapping>
	implements JpaComposite
 * -----------------------------------------------------------------------------
 * | ------------------------------------------------------------------------- |
 * | |                                                                       | |
 * | | ColumnComposite                                                       | |
 * | |                                                                       | |
 * | ------------------------------------------------------------------------- |
 * | ------------------------------------------------------------------------- |
 * | |                                                                       | |
 * | | TemporalTypeComposite                                                 | |
 * | |                                                                       | |
 * | ------------------------------------------------------------------------- |
 * | ------------------------------------------------------------------------- |
 * | |                                                                       | |
 * | | GenerationComposite                                                   | |
 * | |                                                                       | |
 * | ------------------------------------------------------------------------- |
 * -----------------------------------------------------------------------------</pre>
 *
 * @see IdMapping
 * @see JavaUiFactory - The factory creating this pane
 * @see ColumnComposite
 * @see TemporalTypeComposite
 * @see IdMappingGenerationComposite
 *
 * @version 2.3
 * @since 2.1
 */
public class JavaEclipseLinkIdMapping2_0Composite extends EclipseLinkIdMappingComposite<JavaIdMapping>
                                implements JpaComposite
{
	public JavaEclipseLinkIdMapping2_0Composite(
			PropertyValueModel<? extends JavaIdMapping> subjectHolder,
			Composite parent,
			WidgetFactory widgetFactory) {
		
	 * @param widgetFactory The factory used to create various common widgets
	 */
	public JavaEclipseLinkIdMapping2_0Composite(PropertyValueModel<? extends JavaIdMapping> subjectHolder,
	                          Composite parent,
	                          WidgetFactory widgetFactory) {

		super(subjectHolder, parent, widgetFactory);
	}
	
	
	@Override
	protected void initializeIdSection(Composite container) {
		new IdMapping2_0MappedByRelationshipPane(this, getSubjectHolder(), container);
		new ColumnComposite(this, buildColumnHolder(), container);
		new EclipseLinkMutableComposite(this, buildMutableHolder(), container);
	}	
	
	@Override
	protected void initializeGenerationCollapsibleSection(Composite container) {
		new IdMappingGeneration2_0Composite(this, container);
	}
}




package org.eclipse.jpt.eclipselink.ui.internal.v2_0.details.orm;

import org.eclipse.jpt.core.context.orm.OrmIdMapping;
import org.eclipse.jpt.eclipselink.ui.internal.details.EclipseLinkMutableComposite;
import org.eclipse.jpt.eclipselink.ui.internal.v1_1.details.orm.OrmEclipseLinkIdMapping1_1Composite;
import org.eclipse.jpt.ui.WidgetFactory;
import org.eclipse.jpt.ui.internal.details.AccessTypeComposite;
import org.eclipse.jpt.ui.internal.details.ColumnComposite;
import org.eclipse.jpt.ui.internal.details.orm.OrmMappingNameChooser;
import org.eclipse.jpt.ui.internal.jpa2.details.IdMapping2_0MappedByRelationshipPane;
import org.eclipse.jpt.ui.internal.jpa2.details.IdMappingGeneration2_0Composite;
import org.eclipse.jpt.utility.model.value.PropertyValueModel;
import org.eclipse.swt.widgets.Composite;

public class OrmEclipseLinkIdMapping2_0Composite
	extends OrmEclipseLinkIdMapping1_1Composite
{
	public OrmEclipseLinkIdMapping2_0Composite(
			PropertyValueModel<? extends OrmIdMapping> subjectHolder,
			Composite parent,
			WidgetFactory widgetFactory) {
		
	 * @param widgetFactory The factory used to create various common widgets
	 */
	public OrmEclipseLinkIdMapping2_0Composite(PropertyValueModel<? extends OrmIdMapping> subjectHolder,
	                               Composite parent,
	                               WidgetFactory widgetFactory) {

		super(subjectHolder, parent, widgetFactory);
	}
	
	
	@Override
	protected void initializeIdSection(Composite container) {		
		new IdMapping2_0MappedByRelationshipPane(this, getSubjectHolder(), container);
		new ColumnComposite(this, buildColumnHolder(), container);
		new OrmMappingNameChooser(this, getSubjectHolder(), container);
		new AccessTypeComposite(this, buildAccessHolderHolder(), container);
		new EclipseLinkMutableComposite(this, buildMutableHolder(), container);
	}
	
	@Override
	protected void initializeGenerationCollapsibleSection(Composite container) {
		new IdMappingGeneration2_0Composite(this, container);
	}
}
}

Lines 23-29 Link Here

(-)src/org/eclipse/jpt/eclipselink/ui/internal/v2_0/details/orm/EclipseLinkOrmXml2_0UiFactory.java (-2 / +1 lines)
23	import org.eclipse.jpt.core.jpa2.context.orm.OrmElementCollectionMapping2_0;	23	import org.eclipse.jpt.core.jpa2.context.orm.OrmElementCollectionMapping2_0;
24	import org.eclipse.jpt.eclipselink.ui.internal.details.orm.BaseEclipseLinkOrmXmlUiFactory;	24	import org.eclipse.jpt.eclipselink.ui.internal.details.orm.BaseEclipseLinkOrmXmlUiFactory;
25	import org.eclipse.jpt.eclipselink.ui.internal.v1_1.details.orm.OrmEclipseLinkBasicMapping1_1Composite;	25	import org.eclipse.jpt.eclipselink.ui.internal.v1_1.details.orm.OrmEclipseLinkBasicMapping1_1Composite;
26	import org.eclipse.jpt.eclipselink.ui.internal.v1_1.details.orm.OrmEclipseLinkEmbeddedIdMapping1_1Composite;
27	import org.eclipse.jpt.eclipselink.ui.internal.v1_1.details.orm.OrmEclipseLinkVersionMapping1_1Composite;	26	import org.eclipse.jpt.eclipselink.ui.internal.v1_1.details.orm.OrmEclipseLinkVersionMapping1_1Composite;
28	import org.eclipse.jpt.ui.WidgetFactory;	27	import org.eclipse.jpt.ui.WidgetFactory;
29	import org.eclipse.jpt.ui.details.JpaComposite;	28	import org.eclipse.jpt.ui.details.JpaComposite;
Lines 77-83 Link Here
77	PropertyValueModel<OrmEmbeddedIdMapping> subjectHolder,	76	PropertyValueModel<OrmEmbeddedIdMapping> subjectHolder,
78	Composite parent,	77	Composite parent,
79	WidgetFactory widgetFactory) {	78	WidgetFactory widgetFactory) {
80	return new OrmEclipseLinkEmbeddedIdMapping1_1Composite(subjectHolder, parent, widgetFactory);	79	return new OrmEclipseLinkEmbeddedIdMapping2_0Composite(subjectHolder, parent, widgetFactory);
81	}	80	}
82		81
83	@Override	82	@Override





//Remove the Converters section from 1.0 orm id mappings.
//This is supported in EclipseLink in version 1.1, but not 1.0
public class OrmEclipseLinkIdMappingComposite
	extends EclipseLinkIdMappingComposite<OrmIdMapping>
{
	public OrmEclipseLinkIdMappingComposite(
			PropertyValueModel<? extends OrmIdMapping> subjectHolder,
	        Composite parent,
	        WidgetFactory widgetFactory) {
		
	 * @param widgetFactory The factory used to create various common widgets
	 */
	public OrmEclipseLinkIdMappingComposite(PropertyValueModel<? extends OrmIdMapping> subjectHolder,
	                               Composite parent,
	                               WidgetFactory widgetFactory) {

		super(subjectHolder, parent, widgetFactory);
	}
	
	
	@Override
	protected void initializeIdSection(Composite container) {		
		new ColumnComposite(this, buildColumnHolder(), container);
		new OrmMappingNameChooser(this, getSubjectHolder(), container);
		new EclipseLinkMutableComposite(this, buildMutableHolder(), container);
	}	
	
	@Override
	//everything but the 'Define Converter' section.  This is not supported in eclipselink 1.0, but is in 1.1
	protected Pane<EclipseLinkConvert> buildConvertComposite(PropertyValueModel<EclipseLinkConvert> convertHolder, Composite container) {
		return new OrmEclipseLinkConvert1_0Composite(convertHolder, container, getWidgetFactory());
	}
}




import org.eclipse.jpt.utility.model.value.PropertyValueModel;
import org.eclipse.swt.widgets.Composite;

public class OrmEclipseLinkEmbeddedIdMapping1_1Composite
	extends AbstractEmbeddedIdMappingComposite<OrmEmbeddedIdMapping>
	implements JpaComposite
 * -----------------------------------------------------------------------------
 * | ------------------------------------------------------------------------- |
 * | |                                                                       | |
 * | | EmbeddedAttributeOverridesComposite                                   | |
 * | |                                                                       | |
 * | ------------------------------------------------------------------------- |
 * -----------------------------------------------------------------------------</pre>
 *
 * @see EmbeddedIdMapping
 *
 * @version 2.3
 * @since 2.2
 */
public class OrmEclipseLinkEmbeddedIdMapping1_1Composite extends AbstractEmbeddedIdMappingComposite<OrmEmbeddedIdMapping>
                                        implements JpaComposite
{
	public OrmEclipseLinkEmbeddedIdMapping1_1Composite(
			PropertyValueModel<? extends OrmEmbeddedIdMapping> subjectHolder,
			Composite parent,
			WidgetFactory widgetFactory) {
		
	 * @param widgetFactory The factory used to create various common widgets
	 */
	public OrmEclipseLinkEmbeddedIdMapping1_1Composite(PropertyValueModel<? extends OrmEmbeddedIdMapping> subjectHolder,
	                                  Composite parent,
	                                  WidgetFactory widgetFactory) {

		super(subjectHolder, parent, widgetFactory);
	}
	
	
	@Override
	protected void initializeEmbeddedIdSection(Composite container) {
		new OrmMappingNameChooser(this, getSubjectHolder(), container);
		new AccessTypeComposite(this, buildAccessHolderHolder(), container);

		new EmbeddedMappingOverridesComposite(
				this,
				container);
		);
	}	
	
	protected PropertyValueModel<AccessHolder> buildAccessHolderHolder() {

			}
		};
	}
}




import org.eclipse.jpt.utility.model.value.PropertyValueModel;
import org.eclipse.swt.widgets.Composite;

public class OrmEclipseLinkIdMapping1_1Composite
	extends EclipseLinkIdMappingComposite<OrmIdMapping>
{
	public OrmEclipseLinkIdMapping1_1Composite(
			PropertyValueModel<? extends OrmIdMapping> subjectHolder,
	        Composite parent,
	        WidgetFactory widgetFactory) {
		
		super(subjectHolder, parent, widgetFactory);
	}
	
	
	@Override
	protected void initializeIdSection(Composite container) {		
		new ColumnComposite(this, buildColumnHolder(), container);

			}
		};
	}
}




/*******************************************************************************
 *  Copyright (c) 2010  Oracle. 
 *  All rights reserved.  This program and the accompanying materials are 
 *  made available under the terms of the Eclipse Public License v1.0 which 
 *  accompanies this distribution, and is available at 
 *  http://www.eclipse.org/legal/epl-v10.html
 *  
 *  Contributors: 
 *  	Oracle - initial API and implementation
 *******************************************************************************/
package org.eclipse.jpt.eclipselink.ui.internal.v2_0.details.orm;

import org.eclipse.jpt.core.context.orm.OrmEmbeddedIdMapping;
import org.eclipse.jpt.eclipselink.ui.internal.v1_1.details.orm.OrmEclipseLinkEmbeddedIdMapping1_1Composite;
import org.eclipse.jpt.ui.WidgetFactory;
import org.eclipse.jpt.ui.internal.details.AccessTypeComposite;
import org.eclipse.jpt.ui.internal.details.EmbeddedMappingOverridesComposite;
import org.eclipse.jpt.ui.internal.details.orm.OrmMappingNameChooser;
import org.eclipse.jpt.ui.internal.jpa2.details.EmbeddedIdMapping2_0MappedByRelationshipPane;
import org.eclipse.jpt.utility.model.value.PropertyValueModel;
import org.eclipse.swt.widgets.Composite;

public class OrmEclipseLinkEmbeddedIdMapping2_0Composite
	extends OrmEclipseLinkEmbeddedIdMapping1_1Composite
{
	public OrmEclipseLinkEmbeddedIdMapping2_0Composite(
			PropertyValueModel<? extends OrmEmbeddedIdMapping> subjectHolder,
			Composite parent,
			WidgetFactory widgetFactory) {
		
		super(subjectHolder, parent, widgetFactory);
	}
	
	
	@Override
	protected void initializeEmbeddedIdSection(Composite container) {
		new OrmMappingNameChooser(this, getSubjectHolder(), container);
		new AccessTypeComposite(this, buildAccessHolderHolder(), container);
		
		new EmbeddedIdMapping2_0MappedByRelationshipPane(this, getSubjectHolder(), container);
		new EmbeddedMappingOverridesComposite(this, container);
	}
}




import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.part.PageBook;

public final class ElementCollectionValueOverridesComposite
	extends AbstractOverridesComposite<ElementCollectionMapping2_0>
 * <pre>
 * --------------------------------------------------------------------------------
 * |                                                                              |
 * | - Attribute Overrides ------------------------------------------------------ |
 * | | ------------------------------------------------------------------------ | |
 * | | |                                                                      | | |
 * | | | AddRemoveListPane                                                    | | |
 * | | |                                                                      | | |
 * | | ------------------------------------------------------------------------ | |
 * | |                                                                          | |
 * | |   x Override Default                                                     | |
 * | |                                                                          | |
 * | | ------------------------------------------------------------------------ | |
 * | | |                                                                      | | |
 * | | | PageBook (AttributeOverrideComposite/AssociationOverride2_0Composite)| | |
 * | | |                                                                      | | |
 * | | ------------------------------------------------------------------------ | |
 * | ---------------------------------------------------------------------------- |
 * --------------------------------------------------------------------------------</pre>
 *
 * @see ElementCollectionMapping2_0
 * @see AbstractElementCollectionMapping2_0Composite - The parent container
 * @see AttributeOverrideComposite
 * @see AssociationOverride2_0Composite
 *
 * @version 3.0
 * @since 3.0
 */
public final class ElementCollectionValueOverridesComposite extends AbstractOverridesComposite<ElementCollectionMapping2_0>
{
	public ElementCollectionValueOverridesComposite(
			Pane<? extends ElementCollectionMapping2_0> parentPane,
			Composite parent) {
		
	 * @param parentPane The parent controller of this one
	 * @param parent The parent container
	 */
	public ElementCollectionValueOverridesComposite(Pane<? extends ElementCollectionMapping2_0> parentPane,
	                          Composite parent) {

		super(parentPane, parent);
	}
	
	
	@Override
	protected boolean supportsAssociationOverrides() {
		return true;

			}
		};
	}
	
	@Override
	protected PropertyValueModel<AssociationOverrideContainer> buildAssociationOverrideContainerHolder() {
		return new PropertyAspectAdapter<ElementCollectionMapping2_0, AssociationOverrideContainer>(getSubjectHolder()) {

			}
		};
	}
}
}




import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.part.PageBook;

public class Entity2_0OverridesComposite
	extends AbstractEntityOverridesComposite
 * <pre>
 * -----------------------------------------------------------------------------
 * |                                                                           |
 * | - Attribute Overrides --------------------------------------------------- |
 * | | --------------------------------------------------------------------- | |
 * | | |                                                                   | | |
 * | | | AddRemoveListPane                                                 | | |
 * | | |                                                                   | | |
 * | | --------------------------------------------------------------------- | |
 * | |                                                                       | |
 * | |   x Override Default                                                  | |
 * | |                                                                       | |
 * | | --------------------------------------------------------------------- | |
 * | | |                                                                   | | |
 * | | | PageBook (AttributeOverrideComposite/AssociationOverrideComposite)| | |
 * | | |                                                                   | | |
 * | | --------------------------------------------------------------------- | |
 * | ------------------------------------------------------------------------- |
 * -----------------------------------------------------------------------------</pre>
 *
 * @see Entity
 * @see Entity2_0Composite - The parent container
 * @see AttributeOverrideComposite
 * @see AssociationOverride2_0Composite
 *
 * @version 3.0
 * @since 2.2
 */
public class Entity2_0OverridesComposite extends AbstractEntityOverridesComposite
{
	public Entity2_0OverridesComposite(
			Pane<? extends Entity> parentPane,
			Composite parent) {
		
	 * @param parentPane The parent controller of this one
	 * @param parent The parent container
	 */
	public Entity2_0OverridesComposite(Pane<? extends Entity> parentPane,
	                          Composite parent) {

		super(parentPane, parent);
	}
	
	
	@Override
	protected Pane<AssociationOverride> buildAssociationOverridePane(PageBook pageBook, PropertyValueModel<AssociationOverride> associationOverrideHolder) {
		return new AssociationOverride2_0Composite(this, associationOverrideHolder, pageBook);
	}
}
}

Lines 42-48 Link Here

(-)src/org/eclipse/jpt/ui/internal/jpa2/details/JptUiDetailsMessages2_0.java (-1 / +5 lines)
42		42
43	public static String Entity_cacheableLabel;	43	public static String Entity_cacheableLabel;
44	public static String Entity_cacheableWithDefaultLabel;	44	public static String Entity_cacheableWithDefaultLabel;
45		45
		46	public static String EmbeddedIdMapping2_0MappedByRelationshipPane_label;
		47
		48	public static String IdMapping2_0MappedByRelationshipPane_label;
		49
46	public static String OrderingComposite_orderColumn;	50	public static String OrderingComposite_orderColumn;
47		51
48	public static String OrphanRemoval2_0Composite_orphanRemovalLabel;	52	public static String OrphanRemoval2_0Composite_orphanRemovalLabel;




import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.part.PageBook;

public class EmbeddedMapping2_0OverridesComposite
	extends AbstractEmbeddedMappingOverridesComposite<EmbeddedMapping>
 * <pre>
 * -----------------------------------------------------------------------------
 * | ------------------------------------------------------------------------- |
 * | |                                                                       | |
 * | | AddRemoveListPane                                                     | |
 * | |                                                                       | |
 * | ------------------------------------------------------------------------- |
 * |                                                                           |
 * |   x Override Default                                                      |
 * |                                                                           |
 * | ------------------------------------------------------------------------- |
 * | |                                                                       | |
 * | | ColumnComposite                                                       | |
 * | |                                                                       | |
 * | ------------------------------------------------------------------------- |
 * -----------------------------------------------------------------------------</pre>
 *
 * @see EmbeddedMapping
 * @see ColumnComposite
 *
 * @version 2.3
 * @since 2.3
 */
public class EmbeddedMapping2_0OverridesComposite extends AbstractEmbeddedMappingOverridesComposite<EmbeddedMapping>
{
	public EmbeddedMapping2_0OverridesComposite(
			Pane<? extends EmbeddedMapping> parentPane,
			Composite parent) {
		
	 * @param parentPane The parent container of this one
	 * @param parent The parent container
	 */
	public EmbeddedMapping2_0OverridesComposite(Pane<? extends EmbeddedMapping> parentPane,
	                                           Composite parent) {

		super(parentPane, parent);
	}
	
	
	@Override
	protected boolean supportsAssociationOverrides() {
		return true;

			}
		};
	}
	
	@Override
	protected Pane<AssociationOverride> buildAssociationOverridePane(PageBook pageBook, PropertyValueModel<AssociationOverride> associationOverrideHolder) {
		return new AssociationOverride2_0Composite(this, associationOverrideHolder, pageBook);

			}
		};
	}
}
}




package org.eclipse.jpt.ui.internal.details;

import org.eclipse.jpt.core.context.EmbeddedIdMapping;
import org.eclipse.jpt.core.context.EmbeddedMapping;
import org.eclipse.jpt.ui.WidgetFactory;
import org.eclipse.jpt.ui.details.JpaComposite;
import org.eclipse.jpt.ui.internal.widgets.Pane;

import org.eclipse.jpt.utility.model.value.PropertyValueModel;
import org.eclipse.swt.widgets.Composite;

/**
 * Here the layout of this pane:
 * <pre>
 * -----------------------------------------------------------------------------
 * | ------------------------------------------------------------------------- |
 * | |                                                                       | |
 * | | EmbeddedAttributeOverridesComposite                                   | |
 * | |                                                                       | |
 * | ------------------------------------------------------------------------- |
 * -----------------------------------------------------------------------------</pre>
 *
 * @see EmbeddedMapping
 *
 * @version 2.3
 * @since 1.0
 */
public abstract class AbstractEmbeddedIdMappingComposite<T extends EmbeddedIdMapping> 
	extends Pane<T>
	implements JpaComposite
{
	protected AbstractEmbeddedIdMappingComposite(
			PropertyValueModel<? extends T> subjectHolder,
			Composite parent,
			WidgetFactory widgetFactory) {
		
	 * @param widgetFactory The factory used to create various common widgets
	 */
	protected AbstractEmbeddedIdMappingComposite(PropertyValueModel<? extends T> subjectHolder,
	                                Composite parent,
	                                WidgetFactory widgetFactory) {

		super(subjectHolder, parent, widgetFactory);
	}
	
	
	@Override
	protected void initializeLayout(Composite container) {
		initializeEmbeddedIdCollapsibleSection(container);

	
	protected void initializeEmbeddedIdCollapsibleSection(Composite container) {
		container = addCollapsibleSection(
				container,
				JptUiDetailsMessages.EmbeddedIdSection_title,
				new SimplePropertyValueModel<Boolean>(Boolean.TRUE));
		

		this.initializeEmbeddedIdSection(container);
	}
	
	protected abstract void initializeEmbeddedIdSection(Composite container);
}
			this,
			container
		);
	}
}

Lines 13-61 Link Here

(-)src/org/eclipse/jpt/ui/internal/details/EntityOverridesComposite.java (-43 / +7 lines)
13	import org.eclipse.jpt.ui.internal.widgets.Pane;	13	import org.eclipse.jpt.ui.internal.widgets.Pane;
14	import org.eclipse.swt.widgets.Composite;	14	import org.eclipse.swt.widgets.Composite;
15		15
16	/**	16	public class EntityOverridesComposite
17	* Here the layout of this pane:	17	extends AbstractEntityOverridesComposite
18	* <pre>
19	* -----------------------------------------------------------------------------
20	* \| \|
21	* \| - Attribute Overrides --------------------------------------------------- \|
22	* \| \| --------------------------------------------------------------------- \| \|
23	* \| \| \| \| \| \|
24	* \| \| \| AddRemoveListPane \| \| \|
25	* \| \| \| \| \| \|
26	* \| \| --------------------------------------------------------------------- \| \|
27	* \| \| \| \|
28	* \| \| x Override Default \| \|
29	* \| \| \| \|
30	* \| \| --------------------------------------------------------------------- \| \|
31	* \| \| \| \| \| \|
32	* \| \| \| PageBook (AttributeOverrideComposite/AssociationOverrideComposite)\| \| \|
33	* \| \| \| \| \| \|
34	* \| \| --------------------------------------------------------------------- \| \|
35	* \| ------------------------------------------------------------------------- \|
36	* -----------------------------------------------------------------------------</pre>
37	*
38	* @see Entity
39	* @see EntityComposite - The parent container
40	* @see AttributeOverrideComposite
41	* @see AssociationOverrideComposite
42	*
43	* @version 3.0
44	* @since 1.0
45	*/
46	public class EntityOverridesComposite extends AbstractEntityOverridesComposite
47	{	18	{
48		19	public EntityOverridesComposite(
49	/**	20	Pane<? extends Entity> parentPane,
50	* Creates a new <code>OverridesComposite</code>.	21	Composite parent) {
51	*	22
52	* @param parentPane The parent controller of this one
53	* @param parent The parent container
54	*/
55	public EntityOverridesComposite(Pane<? extends Entity> parentPane,
56	Composite parent) {
57
58	super(parentPane, parent);	23	super(parentPane, parent);
59	}	24	}
60		25	}
61	}




import org.eclipse.jpt.utility.model.value.PropertyValueModel;
import org.eclipse.swt.widgets.Composite;

public abstract class AbstractEntityOverridesComposite
	extends AbstractOverridesComposite<Entity>
 * <pre>
 * -----------------------------------------------------------------------------
 * |                                                                           |
 * | - Attribute Overrides --------------------------------------------------- |
 * | | --------------------------------------------------------------------- | |
 * | | |                                                                   | | |
 * | | | AddRemoveListPane                                                 | | |
 * | | |                                                                   | | |
 * | | --------------------------------------------------------------------- | |
 * | |                                                                       | |
 * | |   x Override Default                                                  | |
 * | |                                                                       | |
 * | | --------------------------------------------------------------------- | |
 * | | |                                                                   | | |
 * | | | PageBook (AttributeOverrideComposite/AssociationOverrideComposite)| | |
 * | | |                                                                   | | |
 * | | --------------------------------------------------------------------- | |
 * | ------------------------------------------------------------------------- |
 * -----------------------------------------------------------------------------</pre>
 *
 * @see Entity
 * @see EntityComposite - The parent container
 * @see AttributeOverrideComposite
 * @see AssociationOverrideComposite
 *
 * @version 3.0
 * @since 1.0
 */
public abstract class AbstractEntityOverridesComposite extends AbstractOverridesComposite<Entity>
{
	protected AbstractEntityOverridesComposite(
			Pane<? extends Entity> parentPane,
			Composite parent) {
		
	 * @param parentPane The parent controller of this one
	 * @param parent The parent container
	 */
	protected AbstractEntityOverridesComposite(Pane<? extends Entity> parentPane,
	                          Composite parent) {

		super(parentPane, parent);
	}
	
	
	@Override
	protected boolean supportsAssociationOverrides() {
		return true;

			}
		};
	}
	
	@Override
	protected PropertyValueModel<AssociationOverrideContainer> buildAssociationOverrideContainerHolder() {
		return new PropertyAspectAdapter<Entity, AssociationOverrideContainer>(getSubjectHolder()) {

			}
		};
	}
}
}




import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jpt.core.context.AssociationOverride;

import org.eclipse.swt.widgets.Control;
import org.eclipse.ui.part.PageBook;

/**
 * Here the layout of this pane:
 * <pre>
 * -----------------------------------------------------------------------------
 * |                                                                           |
 * | - Attribute Overrides --------------------------------------------------- |
 * | | --------------------------------------------------------------------- | |
 * | | |                                                                   | | |
 * | | | AddRemoveListPane                                                 | | |
 * | | |                                                                   | | |
 * | | --------------------------------------------------------------------- | |
 * | |                                                                       | |
 * | |   x Override Default                                                  | |
 * | |                                                                       | |
 * | | --------------------------------------------------------------------- | |
 * | | |                                                                   | | |
 * | | | PageBook (attribute/association override composite)               | | |
 * | | |                                                                   | | |
 * | | --------------------------------------------------------------------- | |
 * | ------------------------------------------------------------------------- |
 * -----------------------------------------------------------------------------</pre>
 *
 * @version 3.0
 * @since 1.0
 */
@SuppressWarnings("nls")
public abstract class AbstractOverridesComposite<T extends JpaContextNode>
	extends Pane<T>
{
	private Pane<AttributeOverride> attributeOverridePane;
	private Pane<AssociationOverride> associationOverridePane;
	
	private WritablePropertyValueModel<BaseOverride> selectedOverrideHolder;
	private WritablePropertyValueModel<Boolean> overrideVirtualOverrideHolder;
	
	
	protected AbstractOverridesComposite(
			Pane<? extends T> parentPane,
			Composite parent) {
		
	 */
	protected AbstractOverridesComposite(Pane<? extends T> parentPane,
	                          Composite parent) {

		super(parentPane, parent, false);
	}
	
	
	@Override
	protected void initialize() {
		super.initialize();
		this.selectedOverrideHolder = buildSelectedOverrideHolder();
	}
	
	private WritablePropertyValueModel<BaseOverride> buildSelectedOverrideHolder() {
		return new SimplePropertyValueModel<BaseOverride>();
	}
	
	protected abstract boolean supportsAssociationOverrides();
	
	@Override
	protected void initializeLayout(Composite container) {

		// Overrides group pane
		container = addTitledGroup(
				container,
				JptUiDetailsMessages.OverridesComposite_attributeOverridesGroup);
		

		// Overrides list pane
		initializeOverridesList(container);
		
		int groupBoxMargin = getGroupBoxMargin();
		
		// Override Default check box
		Button overrideCheckBox = addCheckBox(
				addSubPane(container, 0, groupBoxMargin, 0, groupBoxMargin),
				JptUiDetailsMessages.OverridesComposite_overrideDefault,
				getOverrideVirtualOverrideHolder(),
				null);
		);
		SWTTools.controlVisibleState(buildSelectedOverrideBooleanHolder(), overrideCheckBox);
		
		// Property pane

	}
	
	private void initializeOverridesList(Composite container) {

		new AddRemoveListPane<T>(
				this,
				addSubPane(container, 8),
				buildOverridesAdapter(),
				buildOverridesListModel(),
				this.selectedOverrideHolder,
				buildOverrideLabelProvider(),
				JpaHelpContextIds.ENTITY_ATTRIBUTE_OVERRIDES) {
			
		{
			@Override
			protected void initializeButtonPane(Composite container, String helpId) {
				//no buttons: no way to add/remove/edit overrides, they are all defaulted in
			}
			
			@Override
			protected void updateButtons() {
				//no buttons: no way to add/remove/edit overrides, they are all defaulted in

		this.attributeOverridePane = buildAttributeOverridePane(pageBook, attributeOverrideHolder);
		installAttributeOverridePaneEnabler(this.attributeOverridePane, attributeOverrideHolder);
	}
	
	protected Pane<AttributeOverride> buildAttributeOverridePane(PageBook pageBook, PropertyValueModel<AttributeOverride> attributeOverrideHolder) {
		return new AttributeOverrideComposite(this, attributeOverrideHolder, pageBook);
	}
	
	private void installAttributeOverridePaneEnabler(Pane<AttributeOverride> pane, PropertyValueModel<AttributeOverride> overrideHolder) {
		new PaneEnabler(
				buildOverrideBooleanHolder(overrideHolder),
				pane);
		);
	}
	
	private PropertyValueModel<Boolean> buildOverrideBooleanHolder(PropertyValueModel<? extends BaseOverride> overrideHolder) {
		return new CachingTransformationPropertyValueModel<BaseOverride, Boolean>(overrideHolder) {
			@Override

		this.associationOverridePane = buildAssociationOverridePane(pageBook, associationOverrideHolder);
		installAssociationOverridePaneEnabler(this.associationOverridePane, associationOverrideHolder);
	}
	
	protected Pane<AssociationOverride> buildAssociationOverridePane(PageBook pageBook, PropertyValueModel<AssociationOverride> associationOverrideHolder) {
		return new AssociationOverrideComposite(this, associationOverrideHolder, pageBook);		
	}
	
	private void installAssociationOverridePaneEnabler(Pane<AssociationOverride> pane, PropertyValueModel<AssociationOverride> overrideHolder) {
		new PaneEnabler(
				buildOverrideBooleanHolder(overrideHolder),
				pane);
		);
	}
	
	private void installOverrideControlSwitcher(
			PropertyValueModel<BaseOverride> overrideHolder,
			PageBook pageBook) {
		
		new ControlSwitcher(
				overrideHolder,
				buildPaneTransformer(),
				pageBook);
		);
	}
	
	private WritablePropertyValueModel<AssociationOverride> buildAssociationOverrideHolder() {

			protected ListIterator<AssociationOverride> listIterator_() {
				return this.subject.virtualAssociationOverrides();
			}
			
			@Override
			protected int size_() {
				return this.subject.virtualAssociationOverridesSize();
			}
		};
	}
	
	private ListValueModel<AttributeOverride> buildDefaultAttributeOverridesListHolder(PropertyValueModel<AttributeOverrideContainer> containerHolder) {
		return new ListAspectAdapter<AttributeOverrideContainer, AttributeOverride>(containerHolder, AttributeOverrideContainer.VIRTUAL_ATTRIBUTE_OVERRIDES_LIST) {
			@Override
			protected ListIterator<AttributeOverride> listIterator_() {
				return this.subject.virtualAttributeOverrides();
			}
			
			@Override
			protected int size_() {
				return this.subject.virtualAttributeOverridesSize();
			}
		};
	}
	
	protected WritablePropertyValueModel<Boolean> getOverrideVirtualOverrideHolder() {
		if (this.overrideVirtualOverrideHolder == null) {
			this.overrideVirtualOverrideHolder = buildOverrideVirtualOverrideHolder();
		}
		return this.overrideVirtualOverrideHolder;
	}
	

	private WritablePropertyValueModel<Boolean> buildOverrideVirtualOverrideHolder() {
		return new CachingTransformationWritablePropertyValueModel<BaseOverride, Boolean>(this.selectedOverrideHolder) {
			@Override
			public void setValue(Boolean value) {
				updateOverride(value.booleanValue());
			}
			
			@Override
			protected Boolean transform_(BaseOverride value) {
				return Boolean.valueOf(!value.isVirtual());
			}
		};
	}
	
	private String buildOverrideDisplayString(BaseOverride override) {
		String overrideType;
		
		// Retrieve the type
		if (override instanceof AssociationOverride) {
			overrideType = JptUiDetailsMessages.OverridesComposite_association;

		else {
			overrideType = JptUiDetailsMessages.OverridesComposite_attribute;
		}
		
		// Format the name
		String name = override.getName();
		
		if (StringTools.stringIsEmpty(name)) {
			name = JptUiDetailsMessages.OverridesComposite_noName;
		}
		
		// Format: <name> (Attribute/Association Override)
		StringBuilder sb = new StringBuilder();
		sb.append(name);

		sb.append(") ");
		return sb.toString();
	}
	
	protected ILabelProvider buildOverrideLabelProvider() {
		return new LabelProvider() {
			@Override

			}
		};
	}
	
	protected Adapter buildOverridesAdapter() {
		return new AddRemoveListPane.AbstractAdapter() {

			public void addNewItem(ObjectListSelectionModel listSelectionModel) {
				//no way to add/remove/edit overrides, they are all defaulted in
			}
			
			public void removeSelectedItems(ObjectListSelectionModel listSelectionModel) {
				//no way to add/remove/edit overrides, they are all defaulted in
			}
		};
	}
	
	protected ListValueModel<BaseOverride> buildOverridesListHolder() {
		PropertyValueModel<AttributeOverrideContainer> attributeOverrideContainerHolder = buildAttributeOverrideContainerHolder();
		List<ListValueModel<? extends BaseOverride>> list = new ArrayList<ListValueModel<? extends BaseOverride>>();

		
		return new CompositeListValueModel<ListValueModel<? extends BaseOverride>, BaseOverride>(list);
	}
	
	protected abstract PropertyValueModel<AttributeOverrideContainer> buildAttributeOverrideContainerHolder();
	
	protected abstract PropertyValueModel<AssociationOverrideContainer> buildAssociationOverrideContainerHolder();
	
	private ListValueModel<BaseOverride> buildOverridesListModel() {
		return new ItemPropertyListValueModelAdapter<BaseOverride>(
				buildOverridesListHolder(),
				BaseOverride.NAME_PROPERTY);
		);
	}
	
	private Transformer<BaseOverride, Control> buildPaneTransformer() {
		return new Transformer<BaseOverride, Control>() {
			public Control transform(BaseOverride override) {

			}
		};
	}
	
	/**
	 * Given the selected override, return the control that will be displayed
	 */

		if (selectedOverride instanceof AttributeOverride) {
			return AbstractOverridesComposite.this.attributeOverridePane.getControl();
		}
		
		if (selectedOverride instanceof AssociationOverride) {
			return AbstractOverridesComposite.this.associationOverridePane.getControl();
		}
		
		return null;
	}
	

			protected ListIterator<AssociationOverride> listIterator_() {
				return this.subject.specifiedAssociationOverrides();
			}
			
			@Override
			protected int size_() {
				return this.subject.specifiedAssociationOverridesSize();
			}
		};
	}
	
	private ListValueModel<AttributeOverride> buildSpecifiedAttributeOverridesListHolder(PropertyValueModel<AttributeOverrideContainer> containerHolder) {
		return new ListAspectAdapter<AttributeOverrideContainer, AttributeOverride>(containerHolder, AttributeOverrideContainer.SPECIFIED_ATTRIBUTE_OVERRIDES_LIST) {
			@Override
			protected ListIterator<AttributeOverride> listIterator_() {
				return this.subject.specifiedAttributeOverrides();
			}
			
			@Override
			protected int size_() {
				return this.subject.specifiedAttributeOverridesSize();
			}
		};
	}
	
	private void updateOverride(boolean selected) {

		if (isPopulating()) {
			return;
		}
		
		setPopulating(true);
		
		try {
			BaseOverride override = this.selectedOverrideHolder.getValue();
			
			BaseOverride newOverride = override.setVirtual(!selected);
			this.selectedOverrideHolder.setValue(newOverride);
		}

			setPopulating(false);
		}
	}
}




import org.eclipse.jpt.utility.model.value.PropertyValueModel;
import org.eclipse.swt.widgets.Composite;

public class IdMappingComposite
	extends AbstractIdMappingComposite<IdMapping>
 * <pre>
 * -----------------------------------------------------------------------------
 * | ------------------------------------------------------------------------- |
 * | |                                                                       | |
 * | | ColumnComposite                                                       | |
 * | |                                                                       | |
 * | ------------------------------------------------------------------------- |
 * | ------------------------------------------------------------------------- |
 * | |                                                                       | |
 * | | TemporalTypeComposite                                                 | |
 * | |                                                                       | |
 * | ------------------------------------------------------------------------- |
 * | ------------------------------------------------------------------------- |
 * | |                                                                       | |
 * | | GenerationComposite                                                   | |
 * | |                                                                       | |
 * | ------------------------------------------------------------------------- |
 * -----------------------------------------------------------------------------</pre>
 *
 * @see IdMapping
 * @see ColumnComposite
 * @see TemporalTypeComposite
 * @see IdMappingGenerationComposite
 *
 * @version 2.3
 * @since 1.0
 */
public class IdMappingComposite extends AbstractIdMappingComposite<IdMapping>
{
	public IdMappingComposite(
			PropertyValueModel<? extends IdMapping> subjectHolder,
	        Composite parent,
	        WidgetFactory widgetFactory) {
		
	 * @param widgetFactory The factory used to create various common widgets
	 */
	public IdMappingComposite(PropertyValueModel<? extends IdMapping> subjectHolder,
	                          Composite parent,
	                          WidgetFactory widgetFactory) {

		super(subjectHolder, parent, widgetFactory);
	}
	
	
	@Override
	protected void initializeIdSection(Composite container) {
		new ColumnComposite(this, buildColumnHolder(), container);
	}
}





import org.eclipse.jpt.core.context.EmbeddedIdMapping;
import org.eclipse.jpt.ui.WidgetFactory;
import org.eclipse.jpt.ui.details.JpaComposite;
import org.eclipse.jpt.utility.model.value.PropertyValueModel;
import org.eclipse.swt.widgets.Composite;

public class EmbeddedIdMappingComposite
	extends AbstractEmbeddedIdMappingComposite<EmbeddedIdMapping>
 * <pre>
 * -----------------------------------------------------------------------------
 * | ------------------------------------------------------------------------- |
 * | |                                                                       | |
 * | | EmbeddedAttributeOverridesComposite                                   | |
 * | |                                                                       | |
 * | ------------------------------------------------------------------------- |
 * -----------------------------------------------------------------------------</pre>
 *
 * @see EmbeddedIdMapping
 *
 * @version 2.3
 * @since 1.0
 */
public class EmbeddedIdMappingComposite extends AbstractEmbeddedIdMappingComposite<EmbeddedIdMapping>
                                        implements JpaComposite
{
	public EmbeddedIdMappingComposite(
			PropertyValueModel<? extends EmbeddedIdMapping> subjectHolder,
			Composite parent,
			WidgetFactory widgetFactory) {
		
	 * @param widgetFactory The factory used to create various common widgets
	 */
	public EmbeddedIdMappingComposite(PropertyValueModel<? extends EmbeddedIdMapping> subjectHolder,
	                                  Composite parent,
	                                  WidgetFactory widgetFactory) {

		super(subjectHolder, parent, widgetFactory);
	}
	
	
	@Override
	protected void initializeEmbeddedIdSection(Composite container) {
		new EmbeddedMappingOverridesComposite(
				this,
				container);
	}
}




import org.eclipse.jpt.utility.model.value.PropertyValueModel;
import org.eclipse.swt.widgets.Composite;

public class EmbeddedMappingOverridesComposite
	extends AbstractEmbeddedMappingOverridesComposite<BaseEmbeddedMapping>
 * <pre>
 * -----------------------------------------------------------------------------
 * | ------------------------------------------------------------------------- |
 * | |                                                                       | |
 * | | AddRemoveListPane                                                     | |
 * | |                                                                       | |
 * | ------------------------------------------------------------------------- |
 * |                                                                           |
 * |   x Override Default                                                      |
 * |                                                                           |
 * | ------------------------------------------------------------------------- |
 * | |                                                                       | |
 * | | ColumnComposite                                                       | |
 * | |                                                                       | |
 * | ------------------------------------------------------------------------- |
 * -----------------------------------------------------------------------------</pre>
 *
 * @see EmbeddedMapping
 * @see EmbeddedMappingComposite - The parent container
 * @see ColumnComposite
 *
 * @version 2.3
 * @since 1.0
 */
public class EmbeddedMappingOverridesComposite extends AbstractEmbeddedMappingOverridesComposite<BaseEmbeddedMapping>
{
	public EmbeddedMappingOverridesComposite(
			Pane<? extends BaseEmbeddedMapping> parentPane,
			Composite parent) {
		
	 * @param parentPane The parent container of this one
	 * @param parent The parent container
	 */
	public EmbeddedMappingOverridesComposite(Pane<? extends BaseEmbeddedMapping> parentPane,
	                                           Composite parent) {

		super(parentPane, parent);
	}
	
	
	@Override
	protected boolean supportsAssociationOverrides() {
		return false;

	protected PropertyValueModel<AssociationOverrideContainer> buildAssociationOverrideContainerHolder() {
		throw new UnsupportedOperationException();
	}
}
}




import org.eclipse.jpt.utility.model.value.PropertyValueModel;
import org.eclipse.swt.widgets.Composite;

public abstract class AbstractEmbeddedMappingOverridesComposite<T extends BaseEmbeddedMapping>
	extends AbstractOverridesComposite<T>
 * @since 3.0
 */
public abstract class AbstractEmbeddedMappingOverridesComposite<T extends BaseEmbeddedMapping> extends AbstractOverridesComposite<T>
{
	protected AbstractEmbeddedMappingOverridesComposite(
			Pane<? extends T> parentPane,
			Composite parent) {
		
	 * @param parentPane The parent container of this one
	 * @param parent The parent container
	 */
	protected AbstractEmbeddedMappingOverridesComposite(Pane<? extends T> parentPane,
	                                           Composite parent) {

		super(parentPane, parent);
	}
	
	
	@Override
	protected PropertyValueModel<AttributeOverrideContainer> buildAttributeOverrideContainerHolder() {
		return new PropertyAspectAdapter<T, AttributeOverrideContainer>(getSubjectHolder()) {

			}
		};
	}
}

}





import java.util.Collection;
import java.util.Iterator;

import org.eclipse.jpt.core.context.BaseColumn;
import org.eclipse.jpt.core.context.Column;
import org.eclipse.jpt.core.context.NamedColumn;

import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.widgets.Composite;

public class ColumnComposite
	extends Pane<Column>
{
	public ColumnComposite(
			Pane<?> parentPane,
			PropertyValueModel<? extends Column> subjectHolder,
			Composite parent) {
		
 * | ------------------------------------------------------------------------- |
 * | ------------------------------------------------------------------------- |
 * | |                                                                       | |
 * | | TableCombo                                                            | |
 * | |                                                                       | |
 * | ------------------------------------------------------------------------- |
 * |                                                                           |
 * | > Details                                                                 |
 * |                                                                           |
 * |   x Insertable                                                            |
 * |                                                                           |
 * |   x Updatable                                                             |
 * |                                                                           |
 * |   x Unique                                                                |
 * |                                                                           |
 * |   x Nullable                                                              |
 * |                                                                           |
 * |                      ---------------                                      |
 * |   Length:            | I         |I|  Default (XXX)                       |
 * |                      ---------------                                      |
 * |                      ---------------                                      |
 * |   Precision:         | I         |I|  Default (XXX)                       |
 * |                      ---------------                                      |
 * |                      ---------------                                      |
 * |   Scale:             | I         |I|  Default (XXX)                       |
 * |                      ---------------                                      |
 * |                      ---------------------------------------------------- |
 * |   Column Definition: | I                                                | |
 * |                      ---------------------------------------------------- |
 * -----------------------------------------------------------------------------</pre>
 *
 * @see Column
 * @see ColumnCombo
 * @see TableCombo
 * @see BasicMappingComposite - A container of this pane
 * @see EmbeddedMappingOverridesComposite - A container of this pane
 * @see IdMappingComposite - A container of this pane
 * @see VersionMappingComposite - A container of this pane
 *
 * @version 2.0
 * @since 1.0
 */
public class ColumnComposite extends Pane<Column> {

	/**
	 * Creates a new <code>ColumnComposite</code>.
	 *
	 * @param parentPane The parent container of this one
	 * @param subjectHolder The holder of the subject <code>IColumn</code>
	 * @param parent The parent container
	 */
	public ColumnComposite(Pane<?> parentPane,
	                       PropertyValueModel<? extends Column> subjectHolder,
	                       Composite parent) {

		super(parentPane, subjectHolder, parent, false);
	}
	
	public ColumnComposite(
			Pane<?> parentPane,
			PropertyValueModel<? extends Column> subjectHolder,
			Composite parent,
			boolean automaticallyAlignWidgets) {
		
	 * @param automaticallyAlignWidgets <code>true</code> to make the widgets
	 * this pane aligned with the widgets of the given parent controller;
	 * <code>false</code> to not align them
	 */
	public ColumnComposite(Pane<?> parentPane,
	                       PropertyValueModel<? extends Column> subjectHolder,
	                       Composite parent,
	                       boolean automaticallyAlignWidgets) {

		super(parentPane, subjectHolder, parent, automaticallyAlignWidgets);
	}
	
	public ColumnComposite(
			Pane<?> parentPane,
			PropertyValueModel<? extends Column> subjectHolder,
			Composite parent,
			boolean automaticallyAlignWidgets,
			boolean parentManagePane) {
		
	 * this pane aligned with the widgets of the given parent controller;
	 * <code>false</code> to not align them
	 */
	public ColumnComposite(Pane<?> parentPane,
	                       PropertyValueModel<? extends Column> subjectHolder,
	                       Composite parent,
	                       boolean automaticallyAlignWidgets,
	                       boolean parentManagePane) {

		super(parentPane, subjectHolder, parent, automaticallyAlignWidgets, parentManagePane);
	}
	
	
	private ColumnCombo<Column> addColumnCombo(Composite container) {
		
		return new ColumnCombo<Column>(this, container) {

			@Override
			protected void addPropertyNames(Collection<String> propertyNames) {
				super.addPropertyNames(propertyNames);

				propertyNames.add(BaseColumn.DEFAULT_TABLE_PROPERTY);
				propertyNames.add(BaseColumn.SPECIFIED_TABLE_PROPERTY);
			}
			
			@Override
			protected void propertyChanged(String propertyName) {
				if (propertyName == BaseColumn.DEFAULT_TABLE_PROPERTY ||

					super.propertyChanged(propertyName);
				}
			}
			
			@Override
			protected String getDefaultValue() {
				return getSubject().getDefaultName();
			}
			
			@Override
			protected void setValue(String value) {
				getSubject().setSpecifiedName(value);
			}
			
			@Override
			protected Table getDbTable_() {
				return getSubject().getDbTable();
			}
			
			@Override
			protected String getValue() {
				return getSubject().getSpecifiedName();
			}
			
			@Override
			protected String buildNullDefaultValueEntry() {
				return NLS.bind(
						JptUiDetailsMessages.DefaultWithOneParam,
						JptUiDetailsMessages.NoneSelected);
			}
			
			@Override
			public String toString() {
				return "ColumnComposite.columnCombo"; //$NON-NLS-1$
			}
		};
	}
	
	private WritablePropertyValueModel<String> buildColumnDefinitionHolder() {
		return new PropertyAspectAdapter<Column, String>(getSubjectHolder(), NamedColumn.COLUMN_DEFINITION_PROPERTY) {
			@Override
			protected String buildValue_() {
				return this.subject.getColumnDefinition();
			}
			
			@Override
			protected void setValue_(String value) {
				if (value.length() == 0) {

			}
		};
	}
	
	private PropertyValueModel<String> buildInsertableStringHolder() {
		return new TransformationPropertyValueModel<Boolean, String>(buildDefaultInsertableHolder()) {
			@Override

	
	private PropertyValueModel<Boolean> buildDefaultInsertableHolder() {
		return new PropertyAspectAdapter<Column, Boolean>(
				getSubjectHolder(),
				BaseColumn.SPECIFIED_INSERTABLE_PROPERTY,
				BaseColumn.DEFAULT_INSERTABLE_PROPERTY) {
			
			@Override
			protected Boolean buildValue_() {
				if (this.subject.getSpecifiedInsertable() != null) {

			}
		};
	}
	
	private WritablePropertyValueModel<Boolean> buildNullableHolder() {
		return new PropertyAspectAdapter<Column, Boolean>(
				getSubjectHolder(),
				BaseColumn.SPECIFIED_NULLABLE_PROPERTY) {
			
			@Override
			protected Boolean buildValue_() {
				return this.subject.getSpecifiedNullable();
			}
			
			@Override
			protected void setValue_(Boolean value) {
				this.subject.setSpecifiedNullable(value);
			}
		};
	}
	
	private PropertyValueModel<String> buildNullableStringHolder() {
		return new TransformationPropertyValueModel<Boolean, String>(buildDefaultNullableHolder()) {
			@Override

	
	private PropertyValueModel<Boolean> buildDefaultNullableHolder() {
		return new PropertyAspectAdapter<Column, Boolean>(
				getSubjectHolder(),
				BaseColumn.SPECIFIED_NULLABLE_PROPERTY,
				BaseColumn.DEFAULT_NULLABLE_PROPERTY) {
			
			@Override
			protected Boolean buildValue_() {
				if (this.subject.getSpecifiedNullable() != null) {

			}
		};
	}
	
	private Pane<Column> addTableCombo(Composite container) {
		
		return new DatabaseObjectCombo<Column>(this, container) {
			
			@Override
			protected void addPropertyNames(Collection<String> propertyNames) {
				super.addPropertyNames(propertyNames);
				propertyNames.add(BaseColumn.DEFAULT_TABLE_PROPERTY);
				propertyNames.add(BaseColumn.SPECIFIED_TABLE_PROPERTY);
			}
			
			@Override
			protected String getDefaultValue() {
				return this.getSubject().getDefaultTable();
			}
			
			@Override
			protected void setValue(String value) {
				this.getSubject().setSpecifiedTable(value);
			}
			
			@Override
			protected String getValue() {
				return this.getSubject().getSpecifiedTable();
			}
			
			@Override
			protected Iterable<String> getValues_() {
				return CollectionTools.iterable(this.values());
			}
			
			protected Iterator<String> values() {
				return this.getSubject().candidateTableNames();
			}
			
			@Override
			protected String buildNullDefaultValueEntry() {
				return NLS.bind(
						JptUiDetailsMessages.DefaultWithOneParam,
						JptUiDetailsMessages.NoneSelected);
			}
			
			@Override
			public String toString() {
				return "ColumnComposite.tableCombo"; //$NON-NLS-1$
			}
		};
	}
	
	private WritablePropertyValueModel<Boolean> buildUniqueHolder() {
		return new PropertyAspectAdapter<Column, Boolean>(
				getSubjectHolder(),
				BaseColumn.SPECIFIED_UNIQUE_PROPERTY) {
			
			@Override
			protected Boolean buildValue_() {
				return this.subject.getSpecifiedUnique();
			}
			
			@Override
			protected void setValue_(Boolean value) {
				this.subject.setSpecifiedUnique(value);
			}
		};
	}
	
	private PropertyValueModel<String> buildUniqueStringHolder() {
		
		return new TransformationPropertyValueModel<Boolean, String>(buildDefaultUniqueHolder()) {
			
			@Override
			protected String transform(Boolean value) {
				if (value != null) {

	
	private PropertyValueModel<Boolean> buildDefaultUniqueHolder() {
		return new PropertyAspectAdapter<Column, Boolean>(
				getSubjectHolder(),
				BaseColumn.SPECIFIED_UNIQUE_PROPERTY,
				BaseColumn.DEFAULT_UNIQUE_PROPERTY) {
			
			@Override
			protected Boolean buildValue_() {
				if (this.subject.getSpecifiedUnique() != null) {

			}
		};
	}
	
	private WritablePropertyValueModel<Boolean> buildUpdatableHolder() {
		return new PropertyAspectAdapter<Column, Boolean>(
				getSubjectHolder(),
				BaseColumn.DEFAULT_UPDATABLE_PROPERTY,
				BaseColumn.SPECIFIED_UPDATABLE_PROPERTY) {
			
			@Override
			protected Boolean buildValue_() {
				return this.subject.getSpecifiedUpdatable();
			}
			
			@Override
			protected void setValue_(Boolean value) {
				this.subject.setSpecifiedUpdatable(value);
			}
		};
	}
	
	private PropertyValueModel<String> buildUpdatableStringHolder() {
		
		return new TransformationPropertyValueModel<Boolean, String>(buildDefaultUpdatableHolder()) {
			
			@Override
			protected String transform(Boolean value) {
				if (value != null) {

	
	private PropertyValueModel<Boolean> buildDefaultUpdatableHolder() {
		return new PropertyAspectAdapter<Column, Boolean>(
				getSubjectHolder(),
				BaseColumn.SPECIFIED_UPDATABLE_PROPERTY,
				BaseColumn.DEFAULT_UPDATABLE_PROPERTY) {
			
			@Override
			protected Boolean buildValue_() {
				if (this.subject.getSpecifiedUpdatable() != null) {

			}
		};
	}
	
	@Override
	protected void initializeLayout(Composite container) {

		// Column group pane
		container = addTitledGroup(
				container,
				JptUiDetailsMessages.ColumnComposite_columnSection);
		

		// Column widgets
		addLabeledComposite(
				container,
				JptUiDetailsMessages.ColumnComposite_name,
				addColumnCombo(container),
				JpaHelpContextIds.MAPPING_COLUMN);
		

		// Table widgets
		addLabeledComposite(
				container,
				JptUiDetailsMessages.ColumnComposite_table,
				addTableCombo(container),
				JpaHelpContextIds.MAPPING_COLUMN_TABLE);
		

		// Details sub-pane
		container = addCollapsibleSubSection(
				container,
				JptUiDetailsMessages.ColumnComposite_details,
				new SimplePropertyValueModel<Boolean>(Boolean.FALSE));
		

		new DetailsComposite(this, getSubjectHolder(), addSubPane(container, 0, 16));
	}
	
	protected class DetailsComposite extends Pane<Column> {
				
		public DetailsComposite(
				Pane<?> parentPane,
	            PropertyValueModel<? extends Column> subjectHolder,
	            Composite parent) {
			
			super(parentPane, subjectHolder, parent, false);
		}
		
		@Override
		protected void initializeLayout(Composite container) {

			// Insertable tri-state check box
			addTriStateCheckBoxWithDefault(
					addSubPane(container, 4),
					JptUiDetailsMessages.ColumnComposite_insertable,
					buildInsertableHolder(),
					buildInsertableStringHolder(),
					JpaHelpContextIds.MAPPING_COLUMN_INSERTABLE);
			

			// Updatable tri-state check box
			addTriStateCheckBoxWithDefault(
					container,
					JptUiDetailsMessages.ColumnComposite_updatable,
					buildUpdatableHolder(),
					buildUpdatableStringHolder(),
					JpaHelpContextIds.MAPPING_COLUMN_UPDATABLE);
			

			// Unique tri-state check box
			addTriStateCheckBoxWithDefault(
					container,
					JptUiDetailsMessages.ColumnComposite_unique,
					buildUniqueHolder(),
					buildUniqueStringHolder(),
					JpaHelpContextIds.MAPPING_COLUMN_UNIQUE);
			

			// Nullable tri-state check box
			addTriStateCheckBoxWithDefault(
					container,
					JptUiDetailsMessages.ColumnComposite_nullable,
					buildNullableHolder(),
					buildNullableStringHolder(),
					JpaHelpContextIds.MAPPING_COLUMN_NULLABLE);
			

			addLengthCombo(container);
			addPrecisionCombo(container);
			addScaleCombo(container);
			
			// Column Definition widgets
			addLabeledText(
					container,
					JptUiDetailsMessages.ColumnComposite_columnDefinition,
					buildColumnDefinitionHolder());
			);
		}
		
		private void addLengthCombo(Composite container) {
			new IntegerCombo<Column>(this, container) {
				
				@Override
				protected String getLabelText() {
					return JptUiDetailsMessages.ColumnComposite_length;
				}
				
				@Override
				protected String getHelpId() {
					return JpaHelpContextIds.MAPPING_COLUMN_LENGTH;
				}
				
				@Override
				protected PropertyValueModel<Integer> buildDefaultHolder() {
					return new PropertyAspectAdapter<Column, Integer>(getSubjectHolder(), Column.DEFAULT_LENGTH_PROPERTY) {

						protected Integer buildValue_() {
							return this.subject.getSpecifiedLength();
						}
						
						@Override
						protected void setValue_(Integer value) {
							this.subject.setSpecifiedLength(value);

				}
			};
		}
		
		private void addPrecisionCombo(Composite container) {
			new IntegerCombo<Column>(this, container) {	
				
				@Override
				protected String getLabelText() {
					return JptUiDetailsMessages.ColumnComposite_precision;
				}
				
				@Override
				protected String getHelpId() {
					return JpaHelpContextIds.MAPPING_COLUMN_PRECISION;
				}
				
				@Override
				protected PropertyValueModel<Integer> buildDefaultHolder() {
					return new PropertyAspectAdapter<Column, Integer>(getSubjectHolder(), Column.DEFAULT_PRECISION_PROPERTY) {

						protected Integer buildValue_() {
							return this.subject.getSpecifiedPrecision();
						}
						
						@Override
						protected void setValue_(Integer value) {
							this.subject.setSpecifiedPrecision(value);

				}
			};
		}
		
		private void addScaleCombo(Composite container) {
			new IntegerCombo<Column>(this, container) {	
				
				@Override
				protected String getLabelText() {
					return JptUiDetailsMessages.ColumnComposite_scale;
				}
				
				@Override
				protected String getHelpId() {
					return JpaHelpContextIds.MAPPING_COLUMN_SCALE;
				}
				
				@Override
				protected PropertyValueModel<Integer> buildDefaultHolder() {
					return new PropertyAspectAdapter<Column, Integer>(getSubjectHolder(), Column.DEFAULT_SCALE_PROPERTY) {

						protected Integer buildValue_() {
							return this.subject.getSpecifiedScale();
						}
						
						@Override
						protected void setValue_(Integer value) {
							this.subject.setSpecifiedScale(value);

			};
		}
	}
}




import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;

/**
 * Here the layout of this pane:
 * <pre>
 * -----------------------------------------------------------------------------
 * | ------------------------------------------------------------------------- |
 * | |                                                                       | |
 * | | ColumnComposite                                                       | |
 * | |                                                                       | |
 * | ------------------------------------------------------------------------- |
 * | ------------------------------------------------------------------------- |
 * | |                                                                       | |
 * | | TemporalTypeComposite                                                 | |
 * | |                                                                       | |
 * | ------------------------------------------------------------------------- |
 * | ------------------------------------------------------------------------- |
 * | |                                                                       | |
 * | | GenerationComposite                                                   | |
 * | |                                                                       | |
 * | ------------------------------------------------------------------------- |
 * -----------------------------------------------------------------------------</pre>
 *
 * @see IdMapping
 * @see ColumnComposite
 * @see TemporalTypeComposite
 * @see IdMappingGenerationComposite
 *
 * @version 2.3
 * @since 1.0
 */
public abstract class AbstractIdMappingComposite<T extends IdMapping>
	extends Pane<T>
    implements JpaComposite
{
	public AbstractIdMappingComposite(
			PropertyValueModel<? extends T> subjectHolder,
	        Composite parent,
	        WidgetFactory widgetFactory) {
		
	 * @param widgetFactory The factory used to create various common widgets
	 */
	public AbstractIdMappingComposite(PropertyValueModel<? extends T> subjectHolder,
	                          Composite parent,
	                          WidgetFactory widgetFactory) {

		super(subjectHolder, parent, widgetFactory);
	}
	
	
	@Override
	protected void initializeLayout(Composite container) {
		initializeIdCollapsibleSection(container);

	
	protected void initializeIdCollapsibleSection(Composite container) {
		container = addCollapsibleSection(
				container,
				JptUiDetailsMessages.IdSection_title,
				new SimplePropertyValueModel<Boolean>(Boolean.TRUE));
		);

		this.initializeIdSection(container);
	}
	
	protected abstract void initializeIdSection(Composite container);
	
	protected void initializeTypeCollapsibleSection(Composite container) {
		container = addCollapsibleSection(
				container,
				JptUiDetailsMessages.TypeSection_type);
		);
		this.initializeTypeSection(container);
	}
	
	protected void initializeTypeSection(Composite container) {
		((GridLayout) container.getLayout()).numColumns = 2;
		
		// No converter
		Button noConverterButton = addRadioButton(
				container, 
				JptUiDetailsMessages.TypeSection_default, 
				buildConverterBooleanHolder(Converter.NO_CONVERTER), 
				null);
		((GridData) noConverterButton.getLayoutData()).horizontalSpan = 2;
				
		PropertyValueModel<Converter> converterHolder = buildConverterHolder();
		// Temporal
		addRadioButton(
				container, 
				JptUiDetailsMessages.TypeSection_temporal, 
				buildConverterBooleanHolder(Converter.TEMPORAL_CONVERTER), 
				null);
		registerSubPane(new TemporalTypeComposite(buildTemporalConverterHolder(converterHolder), container, getWidgetFactory()));
	}
	
	protected void initializeGenerationCollapsibleSection(Composite container) {
		new IdMappingGenerationComposite(this, container);
	}
	
	protected PropertyValueModel<? extends Column> buildColumnHolder() {
		return new TransformationPropertyValueModel<T, Column>(getSubjectHolder())  {
			@Override

			}
		};
	}
	
	protected WritablePropertyValueModel<Boolean> buildConverterBooleanHolder(final String converterType) {
		return new PropertyAspectAdapter<T, Boolean>(getSubjectHolder(), ConvertibleMapping.CONVERTER_PROPERTY) {
			@Override

				Converter converter = this.subject.getConverter();
				return Boolean.valueOf(converter.getType() == converterType);
			}
			
			@Override
			protected void setValue_(Boolean value) {
				if (value.booleanValue()) {

			}
		};
	}
	

	protected PropertyValueModel<Converter> buildConverterHolder() {
		return new PropertyAspectAdapter<T, Converter>(getSubjectHolder(), ConvertibleMapping.CONVERTER_PROPERTY) {
			@Override

			}
		};
	}
}




import org.eclipse.jpt.ui.details.JpaComposite;
import org.eclipse.jpt.ui.internal.details.AbstractEmbeddedIdMappingComposite;
import org.eclipse.jpt.ui.internal.details.EmbeddedMappingOverridesComposite;
import org.eclipse.jpt.ui.internal.details.orm.OrmMappingNameChooser;
import org.eclipse.jpt.utility.model.value.PropertyValueModel;
import org.eclipse.swt.widgets.Composite;

public class OrmEmbeddedIdMappingComposite
	extends AbstractEmbeddedIdMappingComposite<OrmEmbeddedIdMapping>
	implements JpaComposite
 * -----------------------------------------------------------------------------
 * | ------------------------------------------------------------------------- |
 * | |                                                                       | |
 * | | EmbeddedAttributeOverridesComposite                                   | |
 * | |                                                                       | |
 * | ------------------------------------------------------------------------- |
 * -----------------------------------------------------------------------------</pre>
 *
 * @see EmbeddedIdMapping
 * @see BaseJavaUiFactory - The factory creating this pane
 *
 * @version 2.3
 * @since 2.2
 */
public class OrmEmbeddedIdMappingComposite extends AbstractEmbeddedIdMappingComposite<OrmEmbeddedIdMapping>
                                        implements JpaComposite
{
	public OrmEmbeddedIdMappingComposite(
			PropertyValueModel<? extends OrmEmbeddedIdMapping> subjectHolder,
			Composite parent,
			WidgetFactory widgetFactory) {
		
	 * @param widgetFactory The factory used to create various common widgets
	 */
	public OrmEmbeddedIdMappingComposite(PropertyValueModel<? extends OrmEmbeddedIdMapping> subjectHolder,
	                                  Composite parent,
	                                  WidgetFactory widgetFactory) {

		super(subjectHolder, parent, widgetFactory);
	}
	
	
	@Override
	protected void initializeEmbeddedIdSection(Composite container) {
		new OrmMappingNameChooser(this, getSubjectHolder(), container);

		new EmbeddedMappingOverridesComposite(
				this,
				container);
	}
}
}




import org.eclipse.jpt.ui.WidgetFactory;
import org.eclipse.jpt.ui.internal.details.AbstractIdMappingComposite;
import org.eclipse.jpt.ui.internal.details.ColumnComposite;
import org.eclipse.jpt.ui.internal.details.orm.OrmMappingNameChooser;
import org.eclipse.jpt.utility.model.value.PropertyValueModel;
import org.eclipse.swt.widgets.Composite;

public class OrmIdMappingComposite
	extends AbstractIdMappingComposite<OrmIdMapping>
{
	public OrmIdMappingComposite(
			PropertyValueModel<? extends OrmIdMapping> subjectHolder,
	        Composite parent,
	        WidgetFactory widgetFactory) {
		
		super(subjectHolder, parent, widgetFactory);
	}
	
	
	@Override
	protected void initializeIdSection(Composite container) {
		new ColumnComposite(this, buildColumnHolder(), container);
		new OrmMappingNameChooser(this, getSubjectHolder(), container);
	}
}




package org.eclipse.jpt.ui.internal.jpa2.details.java;

import org.eclipse.jpt.core.context.java.JavaEmbeddable;
import org.eclipse.jpt.core.context.java.JavaEmbeddedIdMapping;
import org.eclipse.jpt.core.context.java.JavaEmbeddedMapping;
import org.eclipse.jpt.core.context.java.JavaEntity;
import org.eclipse.jpt.core.context.java.JavaIdMapping;

import org.eclipse.jpt.ui.details.JpaComposite;
import org.eclipse.jpt.ui.internal.details.java.BaseJavaUiFactory;
import org.eclipse.jpt.ui.internal.jpa2.details.ElementCollectionMapping2_0Composite;
import org.eclipse.jpt.ui.internal.jpa2.details.EmbeddedIdMapping2_0Composite;
import org.eclipse.jpt.ui.internal.persistence.details.GenericPersistenceXmlUiFactory;
import org.eclipse.jpt.ui.jpa2.details.java.JavaUiFactory2_0;
import org.eclipse.jpt.utility.model.value.PropertyValueModel;

	extends BaseJavaUiFactory
	implements JavaUiFactory2_0
{
	// **************** java type mapping composites ***************************
	
	@Override
	public JpaComposite createJavaMappedSuperclassComposite(

			Composite parent, WidgetFactory widgetFactory) {
		return new JavaEmbeddable2_0Composite(subjectHolder, parent, widgetFactory);
	}
	
	
	// **************** java attribute mapping composites **********************
	
	@Override
	public JpaComposite createJavaIdMappingComposite(
			PropertyValueModel<JavaIdMapping> subjectHolder,

	}

	@Override
	public JpaComposite createJavaEmbeddedIdMappingComposite(
			PropertyValueModel<JavaEmbeddedIdMapping> subjectHolder, 
			Composite parent, 
			WidgetFactory widgetFactory) {
		return new EmbeddedIdMapping2_0Composite(subjectHolder, parent, widgetFactory);
	}
	
	@Override
	public JpaComposite createJavaEmbeddedMappingComposite(
			PropertyValueModel<JavaEmbeddedMapping> subjectHolder,
			Composite parent,




import org.eclipse.jpt.ui.WidgetFactory;
import org.eclipse.jpt.ui.internal.details.AbstractIdMappingComposite;
import org.eclipse.jpt.ui.internal.details.ColumnComposite;
import org.eclipse.jpt.ui.internal.jpa2.details.IdMapping2_0MappedByRelationshipPane;
import org.eclipse.jpt.ui.internal.jpa2.details.IdMappingGeneration2_0Composite;
import org.eclipse.jpt.utility.model.value.PropertyValueModel;
import org.eclipse.swt.widgets.Composite;

public class JavaIdMapping2_0Composite
	extends AbstractIdMappingComposite<IdMapping>
 */
public class JavaIdMapping2_0Composite extends AbstractIdMappingComposite<IdMapping>
{
	public JavaIdMapping2_0Composite(
			PropertyValueModel<? extends IdMapping> subjectHolder,
			Composite parent,
			WidgetFactory widgetFactory) {
		
	 * @param widgetFactory The factory used to create various common widgets
	 */
	public JavaIdMapping2_0Composite(PropertyValueModel<? extends IdMapping> subjectHolder,
	                          Composite parent,
	                          WidgetFactory widgetFactory) {

		super(subjectHolder, parent, widgetFactory);
	}
	
	
	@Override
	protected void initializeIdSection(Composite container) {
		new IdMapping2_0MappedByRelationshipPane(this, getSubjectHolder(), container);
		new ColumnComposite(this, buildColumnHolder(), container);
	}
	
	@Override
	protected void initializeGenerationCollapsibleSection(Composite container) {
		new IdMappingGeneration2_0Composite(this, addSubPane(container, 10));
	}
}

Lines 30-35 Link Here

(-)property_files/jpt_ui_details2_0.properties (+3 lines)
30	Entity_cacheableLabel=Cacheable	30	Entity_cacheableLabel=Cacheable
31	Entity_cacheableWithDefaultLabel=Cacheable ({0})	31	Entity_cacheableWithDefaultLabel=Cacheable ({0})
32		32
		33	EmbeddedIdMapping2_0MappedByRelationshipPane_label=This embedded ID is mapped by a relationship
		34	IdMapping2_0MappedByRelationshipPane_label=This ID is mapped by a relationship
		35
33	OrderingComposite_orderColumn=Order column	36	OrderingComposite_orderColumn=Order column
34		37
35	OrphanRemoval2_0Composite_orphanRemovalLabel=Orphan removal	38	OrphanRemoval2_0Composite_orphanRemovalLabel=Orphan removal





BasicSection_title=Basic
EmbeddedSection_title=Embedded
EmbeddedIdSection_title=Embedded ID
EmbeddableSection_title=Embeddable
EntitySection_title=Entity
IdSection_title=ID
ManyToManySection_title=Many to Many
ManyToOneSection_title=Many to One
MappedSuperclassSection_title=Mapped Superclass


BasicMappingUiProvider_label=Basic
EmbeddedMappingUiProvider_label=Embedded
EmbeddedIdMappingUiProvider_label=Embedded ID
IdMappingUiProvider_label=ID
OneToManyMappingUiProvider_label=One to Many
OneToOneMappingUiProvider_label=One to One
ManyToManyMappingUiProvider_label=Many to Many

VersionMappingUiProvider_label=Version
BasicMappingUiProvider_linkLabel=basic
EmbeddedMappingUiProvider_linkLabel=embedded
EmbeddedIdMappingUiProvider_linkLabel=embedded ID
IdMappingUiProvider_linkLabel=ID
OneToManyMappingUiProvider_linkLabel=one to many
OneToOneMappingUiProvider_linkLabel=one to one
ManyToManyMappingUiProvider_linkLabel=many to many




import org.eclipse.jpt.ui.internal.details.AccessTypeComposite;
import org.eclipse.jpt.ui.internal.details.EmbeddedMappingOverridesComposite;
import org.eclipse.jpt.ui.internal.details.orm.OrmMappingNameChooser;
import org.eclipse.jpt.ui.internal.jpa2.details.EmbeddedIdMapping2_0MappedByRelationshipPane;
import org.eclipse.jpt.utility.internal.model.value.PropertyAspectAdapter;
import org.eclipse.jpt.utility.model.value.PropertyValueModel;
import org.eclipse.swt.widgets.Composite;

public class OrmEmbeddedIdMapping2_0Composite
	extends AbstractEmbeddedIdMappingComposite<OrmEmbeddedIdMapping>
	implements JpaComposite
 * -----------------------------------------------------------------------------
 * | ------------------------------------------------------------------------- |
 * | |                                                                       | |
 * | | EmbeddedAttributeOverridesComposite                                   | |
 * | |                                                                       | |
 * | ------------------------------------------------------------------------- |
 * -----------------------------------------------------------------------------</pre>
 *
 * @see EmbeddedIdMapping
 * @see BaseJavaUiFactory - The factory creating this pane
 *
 * @version 2.3
 * @since 2.2
 */
public class OrmEmbeddedIdMapping2_0Composite extends AbstractEmbeddedIdMappingComposite<OrmEmbeddedIdMapping>
                                        implements JpaComposite
{
	public OrmEmbeddedIdMapping2_0Composite(
			PropertyValueModel<? extends OrmEmbeddedIdMapping> subjectHolder,
			Composite parent,
			WidgetFactory widgetFactory) {
		
	 * @param widgetFactory The factory used to create various common widgets
	 */
	public OrmEmbeddedIdMapping2_0Composite(PropertyValueModel<? extends OrmEmbeddedIdMapping> subjectHolder,
	                                  Composite parent,
	                                  WidgetFactory widgetFactory) {

		super(subjectHolder, parent, widgetFactory);
	}
	
	
	@Override
	protected void initializeEmbeddedIdSection(Composite container) {
		new OrmMappingNameChooser(this, getSubjectHolder(), container);
		new AccessTypeComposite(this, buildAccessHolderHolder(), container);
		
		new EmbeddedIdMapping2_0MappedByRelationshipPane(this, getSubjectHolder(), container);
		new EmbeddedMappingOverridesComposite(this, container);
			container
		);
	}	
	
	protected PropertyValueModel<AccessHolder> buildAccessHolderHolder() {

			}
		};
	}
}




import org.eclipse.jpt.ui.internal.details.AccessTypeComposite;
import org.eclipse.jpt.ui.internal.details.ColumnComposite;
import org.eclipse.jpt.ui.internal.details.orm.OrmMappingNameChooser;
import org.eclipse.jpt.ui.internal.jpa2.details.IdMapping2_0MappedByRelationshipPane;
import org.eclipse.jpt.ui.internal.jpa2.details.IdMappingGeneration2_0Composite;
import org.eclipse.jpt.utility.internal.model.value.PropertyAspectAdapter;
import org.eclipse.jpt.utility.model.value.PropertyValueModel;
import org.eclipse.swt.widgets.Composite;

public class OrmIdMapping2_0Composite
	extends AbstractIdMappingComposite<OrmIdMapping>
{
	public OrmIdMapping2_0Composite(
			PropertyValueModel<? extends OrmIdMapping> subjectHolder,
	        Composite parent,
	        WidgetFactory widgetFactory) {
		
		super(subjectHolder, parent, widgetFactory);
	}
	
	
	@Override
	protected void initializeIdSection(Composite container) {
		new IdMapping2_0MappedByRelationshipPane(this, getSubjectHolder(), container);
		new ColumnComposite(this, buildColumnHolder(), container);
		new OrmMappingNameChooser(this, getSubjectHolder(), container);
		new AccessTypeComposite(this, buildAccessHolderHolder(), container);

			}
		};
	}
}




public abstract class ColumnCombo<T extends JpaNode>
	extends DatabaseObjectCombo<T>
{
	public ColumnCombo(
			Pane<? extends T> parentPane, 
			Composite parent) {
		
		super(parentPane, parent);
	}
	
	public ColumnCombo(
			Pane<?> parentPane,
			PropertyValueModel<? extends T> subjectHolder,
			Composite parent) {
		
		super(parentPane, subjectHolder, parent);
	}
	
	public ColumnCombo(
			PropertyValueModel<? extends T> subjectHolder,
			Composite parent,
			WidgetFactory widgetFactory) {
		
		super(subjectHolder, parent, widgetFactory);
	}
	
	
	@Override
	protected Iterable<String> getValues_() {
		Table dbTable = this.getDbTable();
		return (dbTable != null) ? dbTable.getSortedColumnIdentifiers() : EmptyIterable.<String>instance();
	}
	
	protected Table getDbTable() {
		return (this.getSubject() == null) ? null : this.getDbTable_();
	}
	
	/**
	 * Assume the subject is not null.
	 */
	protected abstract Table getDbTable_();
	
	@Override
	protected void tableChanged_(Table table) {
		super.tableChanged_(table);

			this.doPopulate();
		}
	}

}




public abstract class TableCombo<T extends JpaNode>
	extends DatabaseObjectCombo<T>
{
	public TableCombo(
			Pane<? extends T> parentPane,
			Composite parent) {
		
		super(parentPane, parent);
	}
	
	public TableCombo(
			Pane<?> parentPane,
			PropertyValueModel<? extends T> subjectHolder,
			Composite parent) {
		
		super(parentPane, subjectHolder, parent);
	}
	
	public TableCombo(
			PropertyValueModel<? extends T> subjectHolder,
			Composite parent,
			WidgetFactory widgetFactory) {
		
		super(subjectHolder, parent, widgetFactory);
	}
	
	
	@Override
	protected Iterable<String> getValues_() {
		Schema dbSchema = this.getDbSchema();
		return (dbSchema != null) ? dbSchema.getSortedTableIdentifiers() : EmptyIterable.<String>instance();
	}
	
	protected Schema getDbSchema() {
		return (this.getSubject() == null) ? null : this.getDbSchema_();
	}




package org.eclipse.jpt.ui.internal.jpa2.details;

import org.eclipse.jpt.core.jpa2.context.IdMapping2_0;
import org.eclipse.jpt.ui.internal.widgets.Pane;
import org.eclipse.jpt.utility.internal.model.value.PropertyAspectAdapter;
import org.eclipse.jpt.utility.model.value.PropertyValueModel;
import org.eclipse.jpt.utility.model.value.WritablePropertyValueModel;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;


public class IdMapping2_0MappedByRelationshipPane<T extends IdMapping2_0>
	extends Pane<T>
{
	public IdMapping2_0MappedByRelationshipPane(
			Pane<?> parentPane,
			PropertyValueModel<T> subjectHolder,
			Composite parent) {
		
		super(parentPane, subjectHolder, parent);
	}
	
	
	@Override
	protected void initializeLayout(Composite container) {
		Composite subContainer = addSubPane(container, 2, 0, 0, 0, 0);
		Button checkBox = addCheckBox(
				subContainer,
				null,
				buildIsMappedByRelationshipHolder(),
				null);
		checkBox.setEnabled(false);
		addLabel(subContainer, JptUiDetailsMessages2_0.IdMapping2_0MappedByRelationshipPane_label);
	}
	
	protected WritablePropertyValueModel<Boolean> buildIsMappedByRelationshipHolder() {
		return new PropertyAspectAdapter<T, Boolean>(getSubjectHolder(), IdMapping2_0.MAPPED_BY_RELATIONSHIP_PROPERTY) {
			@Override
			protected Boolean buildValue_() {
				return this.subject.isMappedByRelationship();
			}
		};
	}
}




package org.eclipse.jpt.ui.internal.jpa2.details;

import org.eclipse.jpt.core.jpa2.context.EmbeddedIdMapping2_0;
import org.eclipse.jpt.ui.internal.widgets.Pane;
import org.eclipse.jpt.utility.internal.model.value.PropertyAspectAdapter;
import org.eclipse.jpt.utility.model.value.PropertyValueModel;
import org.eclipse.jpt.utility.model.value.WritablePropertyValueModel;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;

public class EmbeddedIdMapping2_0MappedByRelationshipPane<T extends EmbeddedIdMapping2_0>
	extends Pane<T>
{
	public EmbeddedIdMapping2_0MappedByRelationshipPane(
			Pane<?> parentPane,
			PropertyValueModel<T> subjectHolder,
			Composite parent) {
		
		super(parentPane, subjectHolder, parent);
	}
	
	
	@Override
	protected void initializeLayout(Composite container) {
		Composite subContainer = addSubPane(container, 2, 10, 0, 0, 0);
		Button checkBox = addCheckBox(
				subContainer,
				null,
				buildIsMappedByRelationshipHolder(),
				null);
		checkBox.setEnabled(false);
		addLabel(subContainer, JptUiDetailsMessages2_0.EmbeddedIdMapping2_0MappedByRelationshipPane_label);
	}
	
	protected WritablePropertyValueModel<Boolean> buildIsMappedByRelationshipHolder() {
		return new PropertyAspectAdapter<T, Boolean>(getSubjectHolder(), EmbeddedIdMapping2_0.MAPPED_BY_RELATIONSHIP_PROPERTY) {
			@Override
			protected Boolean buildValue_() {
				return this.subject.isMappedByRelationship();
			}
		};
	}	
}




/*******************************************************************************
 *  Copyright (c) 2010  Oracle. 
 *  All rights reserved.  This program and the accompanying materials are 
 *  made available under the terms of the Eclipse Public License v1.0 which 
 *  accompanies this distribution, and is available at 
 *  http://www.eclipse.org/legal/epl-v10.html
 *  
 *  Contributors: 
 *  	Oracle - initial API and implementation
 *******************************************************************************/
package org.eclipse.jpt.ui.internal.jpa2.details;

import org.eclipse.jpt.core.context.EmbeddedIdMapping;
import org.eclipse.jpt.ui.WidgetFactory;
import org.eclipse.jpt.ui.internal.details.AbstractEmbeddedIdMappingComposite;
import org.eclipse.jpt.ui.internal.details.EmbeddedMappingOverridesComposite;
import org.eclipse.jpt.utility.model.value.PropertyValueModel;
import org.eclipse.swt.widgets.Composite;

public class EmbeddedIdMapping2_0Composite
	extends AbstractEmbeddedIdMappingComposite<EmbeddedIdMapping>
{
	public EmbeddedIdMapping2_0Composite(
			PropertyValueModel<? extends EmbeddedIdMapping> subjectHolder,
			Composite parent,
			WidgetFactory widgetFactory) {
		
		super(subjectHolder, parent, widgetFactory);
	}
	
	
	@Override
	protected void initializeEmbeddedIdSection(Composite container) {
		new EmbeddedIdMapping2_0MappedByRelationshipPane(this, getSubjectHolder(), container);
		new EmbeddedMappingOverridesComposite(this, container);
	}
}




import org.eclipse.jpt.utility.internal.CollectionTools;
import org.eclipse.jpt.utility.internal.iterators.CloneListIterator;
import org.eclipse.jpt.utility.internal.iterators.CompositeListIterator;
import org.eclipse.jpt.utility.internal.iterators.EmptyIterator;
import org.eclipse.jpt.utility.internal.iterators.FilteringIterator;
import org.eclipse.wst.validation.internal.provisional.core.IMessage;
import org.eclipse.wst.validation.internal.provisional.core.IReporter;

	}

	protected Iterator<String> allOverridableAssociationNames() {
		return getOwner().allOverridableNames();
		if (overridableTypeMapping != null) {
			return overridableTypeMapping.allOverridableAssociationNames();
		}
		return EmptyIterator.instance();
	}
	

	@SuppressWarnings("unchecked")
	public ListIterator<JavaAssociationOverride> associationOverrides() {
		return new CompositeListIterator<JavaAssociationOverride>(specifiedAssociationOverrides(), virtualAssociationOverrides());

Lines 9-28 Link Here

(-)src/org/eclipse/jpt/core/internal/jpa1/context/java/GenericJavaEmbeddedIdMapping.java (-1 / +152 lines)
9	******************************************************************************/	9	******************************************************************************/
10	package org.eclipse.jpt.core.internal.jpa1.context.java;	10	package org.eclipse.jpt.core.internal.jpa1.context.java;
11		11
		12	import java.util.Collection;
		13	import java.util.Iterator;
		14	import java.util.List;
		15	import org.eclipse.jdt.core.dom.CompilationUnit;
12	import org.eclipse.jpt.core.MappingKeys;	16	import org.eclipse.jpt.core.MappingKeys;
		17	import org.eclipse.jpt.core.context.AttributeMapping;
		18	import org.eclipse.jpt.core.context.TypeMapping;
		19	import org.eclipse.jpt.core.context.java.JavaAttributeOverrideContainer;
13	import org.eclipse.jpt.core.context.java.JavaEmbeddedIdMapping;	20	import org.eclipse.jpt.core.context.java.JavaEmbeddedIdMapping;
14	import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;	21	import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;
15	import org.eclipse.jpt.core.internal.context.java.AbstractJavaBaseEmbeddedMapping;	22	import org.eclipse.jpt.core.internal.context.java.AbstractJavaBaseEmbeddedMapping;
		23	import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages;
		24	import org.eclipse.jpt.core.internal.validation.JpaValidationMessages;
		25	import org.eclipse.jpt.core.jpa2.context.EmbeddedIdMapping2_0;
		26	import org.eclipse.jpt.core.jpa2.context.SingleRelationshipMapping2_0;
16	import org.eclipse.jpt.core.resource.java.EmbeddedIdAnnotation;	27	import org.eclipse.jpt.core.resource.java.EmbeddedIdAnnotation;
		28	import org.eclipse.jpt.utility.internal.CollectionTools;
		29	import org.eclipse.jpt.utility.internal.iterables.CompositeIterable;
		30	import org.eclipse.jpt.utility.internal.iterables.FilteringIterable;
		31	import org.eclipse.jpt.utility.internal.iterables.SubIterableWrapper;
		32	import org.eclipse.jpt.utility.internal.iterators.EmptyIterator;
		33	import org.eclipse.jpt.utility.internal.iterators.FilteringIterator;
		34	import org.eclipse.jpt.utility.internal.iterators.TransformationIterator;
		35	import org.eclipse.wst.validation.internal.provisional.core.IMessage;
		36	import org.eclipse.wst.validation.internal.provisional.core.IReporter;
17		37
18	public class GenericJavaEmbeddedIdMapping	38	public class GenericJavaEmbeddedIdMapping
19	extends AbstractJavaBaseEmbeddedMapping<EmbeddedIdAnnotation>	39	extends AbstractJavaBaseEmbeddedMapping<EmbeddedIdAnnotation>
20	implements JavaEmbeddedIdMapping	40	implements EmbeddedIdMapping2_0, JavaEmbeddedIdMapping
21	{	41	{
		42	/* 2.0 feature - a relationship may map this embedded id */
		43	protected boolean mappedByRelationship;
		44
		45
22	public GenericJavaEmbeddedIdMapping(JavaPersistentAttribute parent) {	46	public GenericJavaEmbeddedIdMapping(JavaPersistentAttribute parent) {
23	super(parent);	47	super(parent);
24	}	48	}
25		49
		50
26	//**************** JavaAttributeMapping implementation *****************	51	//**************** JavaAttributeMapping implementation *****************
27		52
28	public String getKey() {	53	public String getKey() {
Lines 32-35 Link Here
32	public String getAnnotationName() {	57	public String getAnnotationName() {
33	return EmbeddedIdAnnotation.ANNOTATION_NAME;	58	return EmbeddedIdAnnotation.ANNOTATION_NAME;
34	}	59	}
		60
		61
		62	// ************** EmbeddedId2_0 impl **********************************
		63
		64	public boolean isMappedByRelationship() {
		65	return this.mappedByRelationship;
		66	}
		67
		68	protected void setMappedByRelationship(boolean newValue) {
		69	boolean oldValue = this.mappedByRelationship;
		70	this.mappedByRelationship = newValue;
		71	firePropertyChanged(MAPPED_BY_RELATIONSHIP_PROPERTY, oldValue, newValue);
		72	}
		73
		74	protected boolean calculateMappedByRelationship() {
		75	for (SingleRelationshipMapping2_0 each : getMapsIdRelationships()) {
		76	if (getName().equals(each.getDerivedIdentity().getMapsIdDerivedIdentityStrategy().getValue())) {
		77	return true;
		78	}
		79	}
		80	return false;
		81	}
		82
		83	protected Iterable<SingleRelationshipMapping2_0> getMapsIdRelationships() {
		84	return new FilteringIterable<SingleRelationshipMapping2_0>(
		85	new SubIterableWrapper<AttributeMapping, SingleRelationshipMapping2_0>(
		86	new CompositeIterable<AttributeMapping>(
		87	getTypeMapping().getAllAttributeMappings(MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY),
		88	getTypeMapping().getAllAttributeMappings(MappingKeys.MANY_TO_ONE_ATTRIBUTE_MAPPING_KEY)))) {
		89	@Override
		90	protected boolean accept(SingleRelationshipMapping2_0 o) {
		91	return o.getDerivedIdentity().usesMapsIdDerivedIdentityStrategy();
		92	}
		93	};
		94	}
		95
		96
		97	// ************** overrides *******************************************
		98
		99	@Override
		100	protected Iterator<String> embeddableOverrideableAttributeMappingNames() {
		101	return (isMappedByRelationship()) ?
		102	EmptyIterator.<String>instance()
		103	: super.embeddableOverrideableAttributeMappingNames();
		104	}
		105
		106	@Override
		107	protected JavaAttributeOverrideContainer.Owner buildAttributeOverrideContainerOwner() {
		108	return new AttributeOverrideContainerOwner();
		109	}
		110
		111
		112	protected class AttributeOverrideContainerOwner
		113	extends AbstractJavaBaseEmbeddedMapping.AttributeOverrideContainerOwner
		114	{
		115	@Override
		116	public Iterator allOverridableNames() {
		117	return (GenericJavaEmbeddedIdMapping.this.isMappedByRelationship()) ?
		118	EmptyIterator.<String>instance()
		119	: super.allOverridableNames();
		120	}
		121
		122	@Override
		123	protected Iterator allOverridableAttributeNames_(TypeMapping typeMapping) {
124	final Collection mappedByRelationshipAttributes = CollectionTools.collection(
125	new TransformationIterator<SingleRelationshipMapping2_0, String>(getMapsIdRelationships()) {
126	@Override
127	protected String transform(SingleRelationshipMapping2_0 next) {
128	return next.getDerivedIdentity().getMapsIdDerivedIdentityStrategy().getValue();
129	}
130	});
131	return new FilteringIterator<String>(super.allOverridableAttributeNames_(typeMapping)) {
132	@Override
133	protected boolean accept(String o) {
134	if (mappedByRelationshipAttributes.isEmpty()) {
135	return true;
136	}
137	// overrideable names are (usually?) qualified with a container mapping,
138	// which may also be the one mapped by a relationship
139	String qualifier =
140	(o.indexOf('.') > 0) ?
141	o.substring(0, o.indexOf('.'))
142	: o;
143	return ! mappedByRelationshipAttributes.contains(qualifier);
144	}
145	};
146	}
147	}
148
149
150	// ************** resource -> context *********************************
151
152	@Override
153	protected void initialize() {
154	super.initialize();
155	this.mappedByRelationship = calculateMappedByRelationship();
156	}
157
158
159	@Override
160	protected void update() {
161	super.update();
162	setMappedByRelationship(calculateMappedByRelationship());
163	}
164
165
166	// ************** validation ******************************************
167
168	@Override
169	public void validate(List<IMessage> messages, IReporter reporter, CompilationUnit astRoot) {
170	super.validate(messages, reporter, astRoot);
171
172	// [JPA 2.0] if the embedded id is mapped by a relationship, then any specified
173	// attribute overrides are in error
174	// (in JPA 1.0, this will obviously never be reached)
175	if (isMappedByRelationship()
176	&& getAttributeOverrideContainer().specifiedAttributeOverridesSize() > 0) {
177	messages.add(
178	DefaultJpaValidationMessages.buildMessage(
179	IMessage.HIGH_SEVERITY,
180	JpaValidationMessages.EMBEDDED_ID_MAPPING_MAPPED_BY_RELATIONSHIP_AND_ATTRIBUTE_OVERRIDES_SPECIFIED,
181	new String[] {},
182	getAttributeOverrideContainer(),
183	getAttributeOverrideContainer().getValidationTextRange(astRoot)));
184	}
185	}
35	}	186	}

Lines 12-17 Link Here

(-)src/org/eclipse/jpt/core/internal/jpa1/context/java/GenericJavaAttributeOverride.java (-20 / +112 lines)
12	import java.util.Iterator;	12	import java.util.Iterator;
13	import java.util.List;	13	import java.util.List;
14	import org.eclipse.jdt.core.dom.CompilationUnit;	14	import org.eclipse.jdt.core.dom.CompilationUnit;
		15	import org.eclipse.jpt.core.MappingKeys;
		16	import org.eclipse.jpt.core.context.AttributeMapping;
15	import org.eclipse.jpt.core.context.BaseColumn;	17	import org.eclipse.jpt.core.context.BaseColumn;
16	import org.eclipse.jpt.core.context.Column;	18	import org.eclipse.jpt.core.context.Column;
17	import org.eclipse.jpt.core.context.NamedColumn;	19	import org.eclipse.jpt.core.context.NamedColumn;
Lines 20-46 Link Here
20	import org.eclipse.jpt.core.context.java.JavaAttributeOverrideContainer;	22	import org.eclipse.jpt.core.context.java.JavaAttributeOverrideContainer;
21	import org.eclipse.jpt.core.context.java.JavaColumn;	23	import org.eclipse.jpt.core.context.java.JavaColumn;
22	import org.eclipse.jpt.core.internal.context.java.AbstractJavaOverride;	24	import org.eclipse.jpt.core.internal.context.java.AbstractJavaOverride;
		25	import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages;
		26	import org.eclipse.jpt.core.internal.validation.JpaValidationMessages;
		27	import org.eclipse.jpt.core.jpa2.context.AttributeOverride2_0;
		28	import org.eclipse.jpt.core.jpa2.context.SingleRelationshipMapping2_0;
23	import org.eclipse.jpt.core.resource.java.AttributeOverrideAnnotation;	29	import org.eclipse.jpt.core.resource.java.AttributeOverrideAnnotation;
24	import org.eclipse.jpt.core.resource.java.ColumnAnnotation;	30	import org.eclipse.jpt.core.resource.java.ColumnAnnotation;
25	import org.eclipse.jpt.core.utility.TextRange;	31	import org.eclipse.jpt.core.utility.TextRange;
26	import org.eclipse.jpt.db.Table;	32	import org.eclipse.jpt.db.Table;
27	import org.eclipse.jpt.utility.Filter;	33	import org.eclipse.jpt.utility.Filter;
		34	import org.eclipse.jpt.utility.internal.iterables.CompositeIterable;
		35	import org.eclipse.jpt.utility.internal.iterables.FilteringIterable;
		36	import org.eclipse.jpt.utility.internal.iterables.SubIterableWrapper;
28	import org.eclipse.wst.validation.internal.provisional.core.IMessage;	37	import org.eclipse.wst.validation.internal.provisional.core.IMessage;
29	import org.eclipse.wst.validation.internal.provisional.core.IReporter;	38	import org.eclipse.wst.validation.internal.provisional.core.IReporter;
30		39
31		40	public class GenericJavaAttributeOverride
32	public class GenericJavaAttributeOverride extends AbstractJavaOverride	41	extends AbstractJavaOverride
33	implements JavaAttributeOverride	42	implements AttributeOverride2_0, JavaAttributeOverride
34	{	43	{
35
36	protected final JavaColumn column;	44	protected final JavaColumn column;
37		45
38		46	/* 2.0 feature - a relationship may map this attribute override */
39	public GenericJavaAttributeOverride(JavaAttributeOverrideContainer parent, JavaAttributeOverride.Owner owner) {	47	protected boolean mappedByRelationship;
		48
		49
		50	public GenericJavaAttributeOverride(
		51	JavaAttributeOverrideContainer parent,
		52	JavaAttributeOverride.Owner owner) {
		53
40	super(parent, owner);	54	super(parent, owner);
41	this.column = getJpaFactory().buildJavaColumn(this, this);	55	this.column = getJpaFactory().buildJavaColumn(this, this);
42	}	56	}
43		57
		58
44	@Override	59	@Override
45	public JavaAttributeOverride setVirtual(boolean virtual) {	60	public JavaAttributeOverride setVirtual(boolean virtual) {
46	return (JavaAttributeOverride) super.setVirtual(virtual);	61	return (JavaAttributeOverride) super.setVirtual(virtual);
Lines 63-70 Link Here
63	public ColumnAnnotation getResourceColumnOrNull() {	78	public ColumnAnnotation getResourceColumnOrNull() {
64	return this.getOverrideAnnotation().getColumn();	79	return this.getOverrideAnnotation().getColumn();
65	}	80	}
66		81
		82	protected boolean isColumnSpecified() {
		83	return getResourceColumn() != null;
		84	}
		85
		86
67	//*********** NamedColumn.Owner implementation ************	87	//*********** NamedColumn.Owner implementation ************
		88
68	public TypeMapping getTypeMapping() {	89	public TypeMapping getTypeMapping() {
69	return this.getOwner().getTypeMapping();	90	return this.getOwner().getTypeMapping();
70	}	91	}
Lines 81-88 Link Here
81	return column.getName();	102	return column.getName();
82	}	103	}
83		104
		105
84	//*********** BaseColumn.Owner implementation ************	106	//*********** BaseColumn.Owner implementation ************
85		107
86	public String getDefaultTableName() {	108	public String getDefaultTableName() {
87	Column column = resolveOverriddenColumn();	109	Column column = resolveOverriddenColumn();
88	if (column == null) {	110	if (column == null) {
Lines 94-104 Link Here
94	}	116	}
95	return getOwner().getDefaultTableName();	117	return getOwner().getDefaultTableName();
96	}	118	}
97		119
98	protected Column resolveOverriddenColumn() {	120	protected Column resolveOverriddenColumn() {
99	return getOwner().resolveOverriddenColumn(getName());	121	return getOwner().resolveOverriddenColumn(getName());
100	}	122	}
101		123
102	public boolean tableNameIsInvalid(String tableName) {	124	public boolean tableNameIsInvalid(String tableName) {
103	return getOwner().tableNameIsInvalid(tableName);	125	return getOwner().tableNameIsInvalid(tableName);
104	}	126	}
Lines 107-118 Link Here
107	return getOwner().candidateTableNames();	129	return getOwner().candidateTableNames();
108	}	130	}
109		131
		132
110	//*********** AttributeOverride implementation ************	133	//*********** AttributeOverride implementation ************
111		134
112	public JavaColumn getColumn() {	135	public JavaColumn getColumn() {
113	return this.column;	136	return this.column;
114	}	137	}
115		138
		139
116	//*********** JavaOverride implementation ************	140	//*********** JavaOverride implementation ************
117		141
118	@Override	142	@Override
Lines 120-136 Link Here
120	return this.getOwner().allOverridableAttributeNames();	144	return this.getOwner().allOverridableAttributeNames();
121	}	145	}
122		146
		147
		148	// ************** AttributeOverride2_0 impl ***************************
		149
		150	public boolean isMappedByRelationship() {
		151	return this.mappedByRelationship;
		152	}
		153
		154	protected void setMappedByRelationship(boolean newValue) {
		155	boolean oldValue = this.mappedByRelationship;
		156	this.mappedByRelationship = newValue;
		157	firePropertyChanged(MAPPED_BY_RELATIONSHIP_PROPERTY, oldValue, newValue);
		158	}
		159
		160	protected boolean calculateMappedByRelationship() {
		161	for (SingleRelationshipMapping2_0 each : getMapsIdRelationships()) {
		162	if (getName() == null) {
		163	return false;
		164	}
		165
		166	// overrideable names are (usually?) qualified with a container mapping,
		167	// which may also be the one mapped by a relationship
		168	String qualifier =
		169	(getName().indexOf('.') > 0) ?
		170	getName().substring(0, getName().indexOf('.'))
		171	: getName();
		172	return qualifier.equals(each.getDerivedIdentity().getMapsIdDerivedIdentityStrategy().getValue());
		173	}
		174	return false;
		175	}
		176
		177	protected Iterable<SingleRelationshipMapping2_0> getMapsIdRelationships() {
		178	return new FilteringIterable<SingleRelationshipMapping2_0>(
		179	new SubIterableWrapper<AttributeMapping, SingleRelationshipMapping2_0>(
		180	new CompositeIterable<AttributeMapping>(
		181	getTypeMapping().getAllAttributeMappings(MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY),
		182	getTypeMapping().getAllAttributeMappings(MappingKeys.MANY_TO_ONE_ATTRIBUTE_MAPPING_KEY)))) {
		183	@Override
		184	protected boolean accept(SingleRelationshipMapping2_0 o) {
		185	return o.getDerivedIdentity().usesMapsIdDerivedIdentityStrategy();
		186	}
		187	};
		188	}
		189
		190
123	//*********** java resource model -> java context model ************	191	//*********** java resource model -> java context model ************
		192
124	public void initialize(AttributeOverrideAnnotation attributeOverrideResource) {	193	public void initialize(AttributeOverrideAnnotation attributeOverrideResource) {
125	super.initialize(attributeOverrideResource);	194	super.initialize(attributeOverrideResource);
126	this.column.initialize(this.getResourceColumn());	195	this.column.initialize(this.getResourceColumn());
		196	this.mappedByRelationship = calculateMappedByRelationship();
127	}	197	}
128		198
129	public void update(AttributeOverrideAnnotation attributeOverrideResource) {	199	public void update(AttributeOverrideAnnotation attributeOverrideResource) {
130	super.update(attributeOverrideResource);	200	super.update(attributeOverrideResource);
131	this.column.update(this.getResourceColumn());	201	this.column.update(this.getResourceColumn());
		202	setMappedByRelationship(calculateMappedByRelationship());
132	}	203	}
133		204
134	@Override	205	@Override
135	public Iterator<String> javaCompletionProposals(int pos, Filter<String> filter, CompilationUnit astRoot) {	206	public Iterator<String> javaCompletionProposals(int pos, Filter<String> filter, CompilationUnit astRoot) {
136	Iterator<String> result = super.javaCompletionProposals(pos, filter, astRoot);	207	Iterator<String> result = super.javaCompletionProposals(pos, filter, astRoot);
Lines 143-162 Link Here
143	}	214	}
144	return null;	215	return null;
145	}	216	}
146		217
147		218
148	// ******** validation ********	219	// ******** validation ********
149		220
150	@Override	221	@Override
151	public void validate(List<IMessage> messages, IReporter reporter, CompilationUnit astRoot) {	222	public void validate(List<IMessage> messages, IReporter reporter, CompilationUnit astRoot) {
152	super.validate(messages, reporter, astRoot);	223	super.validate(messages, reporter, astRoot);
153	getColumn().validate(messages, reporter, astRoot);	224
		225	// [JPA 2.0] if the column is specified, or if the override is not mapped by a relationship,
		226	// then the column is validated.
		227	// (In JPA 1.0, the column will always be validated, since the override is never mapped by a
		228	// relationship)
		229	if (isColumnSpecified() \|\| ! isMappedByRelationship()) {
		230	getColumn().validate(messages, reporter, astRoot);
		231	}
		232
		233	// [JPA 2.0] if the override is mapped by a relationship, then that actually is in itself
		234	// a validation error
		235	// (We prevent implied overrides that are mapped by a relationship ... hopefully)
		236	// (In JPA 1.0, this will never occur)
		237	if (isMappedByRelationship()) {
		238	messages.add(
		239	DefaultJpaValidationMessages.buildMessage(
		240	IMessage.HIGH_SEVERITY,
		241	JpaValidationMessages.ATTRIBUTE_OVERRIDE_MAPPED_BY_RELATIONSHIP_AND_SPECIFIED,
		242	new String[] {},
		243	this,
		244	getValidationTextRange(astRoot)));
		245	}
154	}	246	}
155		247
156	public IMessage buildUnresolvedNameMessage(NamedColumn column, TextRange textRange) {	248	public IMessage buildUnresolvedNameMessage(NamedColumn column, TextRange textRange) {
157	return getOwner().buildColumnUnresolvedNameMessage(this, column, textRange);	249	return getOwner().buildColumnUnresolvedNameMessage(this, column, textRange);
158	}	250	}
159		251
160	public IMessage buildTableNotValidMessage(BaseColumn column, TextRange textRange) {	252	public IMessage buildTableNotValidMessage(BaseColumn column, TextRange textRange) {
161	return getOwner().buildColumnTableNotValidMessage(this, column, textRange);	253	return getOwner().buildColumnTableNotValidMessage(this, column, textRange);
162	}	254	}




import org.eclipse.jpt.core.context.java.JavaJpaContextNode;
import org.eclipse.jpt.core.internal.context.java.AbstractJavaJpaContextNode;
import org.eclipse.jpt.core.internal.context.java.VirtualAttributeOverrideAnnotation;
import org.eclipse.jpt.core.resource.java.Annotation;
import org.eclipse.jpt.core.resource.java.AttributeOverrideAnnotation;
import org.eclipse.jpt.core.resource.java.AttributeOverridesAnnotation;
import org.eclipse.jpt.core.resource.java.JavaResourcePersistentMember;

import org.eclipse.jpt.utility.internal.CollectionTools;
import org.eclipse.jpt.utility.internal.iterators.CloneListIterator;
import org.eclipse.jpt.utility.internal.iterators.CompositeListIterator;
import org.eclipse.jpt.utility.internal.iterators.EmptyIterator;
import org.eclipse.jpt.utility.internal.iterators.FilteringIterator;
import org.eclipse.wst.validation.internal.provisional.core.IMessage;
import org.eclipse.wst.validation.internal.provisional.core.IReporter;

	}

	protected Iterator<String> allOverridableAttributeNames() {
		return getOwner().allOverridableNames();
		if (overridableTypeMapping != null) {
			return overridableTypeMapping.allOverridableAttributeNames();
		}
		return EmptyIterator.instance();
	}

	
	public void initialize(JavaResourcePersistentMember resourcePersistentMember) {
		this.javaResourcePersistentMember = resourcePersistentMember;

	}

	public TextRange getValidationTextRange(CompilationUnit astRoot) {
		Annotation annotation = 
				this.javaResourcePersistentMember.getAnnotation(AttributeOverridesAnnotation.ANNOTATION_NAME);
		if (annotation == null) {
			annotation = this.javaResourcePersistentMember.getAnnotation(AttributeOverrideAnnotation.ANNOTATION_NAME);
		}
		
		return (annotation == null) ?
				getOwner().getValidationTextRange(astRoot)
				: annotation.getTextRange(astRoot);
	}

	
	
	// ********** attribute override owner **********

Lines 12-18 Link Here

(-)src/org/eclipse/jpt/core/internal/jpa1/context/java/GenericJavaEmbeddedMapping.java (-21 / +29 lines)
12	import java.util.Iterator;	12	import java.util.Iterator;
13	import java.util.List;	13	import java.util.List;
14	import java.util.Vector;	14	import java.util.Vector;
15
16	import org.eclipse.jdt.core.dom.CompilationUnit;	15	import org.eclipse.jdt.core.dom.CompilationUnit;
17	import org.eclipse.jpt.core.MappingKeys;	16	import org.eclipse.jpt.core.MappingKeys;
18	import org.eclipse.jpt.core.context.AssociationOverride;	17	import org.eclipse.jpt.core.context.AssociationOverride;
Lines 39-44 Link Here
39	import org.eclipse.jpt.utility.internal.CollectionTools;	38	import org.eclipse.jpt.utility.internal.CollectionTools;
40	import org.eclipse.jpt.utility.internal.Transformer;	39	import org.eclipse.jpt.utility.internal.Transformer;
41	import org.eclipse.jpt.utility.internal.iterators.CompositeIterator;	40	import org.eclipse.jpt.utility.internal.iterators.CompositeIterator;
		41	import org.eclipse.jpt.utility.internal.iterators.EmptyIterator;
42	import org.eclipse.wst.validation.internal.provisional.core.IMessage;	42	import org.eclipse.wst.validation.internal.provisional.core.IMessage;
43	import org.eclipse.wst.validation.internal.provisional.core.IReporter;	43	import org.eclipse.wst.validation.internal.provisional.core.IReporter;
44		44
Lines 188-203 Link Here
188		188
189	// ******** association override container owner ********	189	// ******** association override container owner ********
190		190
191	class AssociationOverrideContainerOwner implements JavaAssociationOverrideContainer.Owner {	191	class AssociationOverrideContainerOwner
		192	implements JavaAssociationOverrideContainer.Owner
		193	{
		194	public TypeMapping getTypeMapping() {
		195	return GenericJavaEmbeddedMapping.this.getTypeMapping();
		196	}
192		197
193	public TypeMapping getOverridableTypeMapping() {	198	public TypeMapping getOverridableTypeMapping() {
194	return GenericJavaEmbeddedMapping.this.getOverridableTypeMapping();	199	return GenericJavaEmbeddedMapping.this.getOverridableTypeMapping();
195	}	200	}
196		201
197	public TypeMapping getTypeMapping() {	202	public Iterator<String> allOverridableNames() {
198	return GenericJavaEmbeddedMapping.this.getTypeMapping();	203	TypeMapping typeMapping = getOverridableTypeMapping();
		204	return (typeMapping == null) ?
		205	EmptyIterator.<String>instance()
		206	: typeMapping.allOverridableAssociationNames();
199	}	207	}
200		208
201	public RelationshipReference resolveRelationshipReference(String associationOverrideName) {	209	public RelationshipReference resolveRelationshipReference(String associationOverrideName) {
202	return MappingTools.resolveRelationshipReference(getOverridableTypeMapping(), associationOverrideName);	210	return MappingTools.resolveRelationshipReference(getOverridableTypeMapping(), associationOverrideName);
203	}	211	}
Lines 205-215 Link Here
205	public boolean tableNameIsInvalid(String tableName) {	213	public boolean tableNameIsInvalid(String tableName) {
206	return getTypeMapping().tableNameIsInvalid(tableName);	214	return getTypeMapping().tableNameIsInvalid(tableName);
207	}	215	}
208		216
209	public Iterator<String> candidateTableNames() {	217	public Iterator<String> candidateTableNames() {
210	return getTypeMapping().associatedTableNamesIncludingInherited();	218	return getTypeMapping().associatedTableNamesIncludingInherited();
211	}	219	}
212		220
213	public org.eclipse.jpt.db.Table getDbTable(String tableName) {	221	public org.eclipse.jpt.db.Table getDbTable(String tableName) {
214	return getTypeMapping().getDbTable(tableName);	222	return getTypeMapping().getDbTable(tableName);
215	}	223	}
Lines 217-240 Link Here
217	public String getDefaultTableName() {	225	public String getDefaultTableName() {
218	return getTypeMapping().getPrimaryTableName();	226	return getTypeMapping().getPrimaryTableName();
219	}	227	}
220		228
221	public String getPossiblePrefix() {	229	public String getPossiblePrefix() {
222	return null;	230	return null;
223	}	231	}
224		232
225	public String getWritePrefix() {	233	public String getWritePrefix() {
226	return null;	234	return null;
227	}	235	}
228		236
229	//no prefix, so always true	237	//no prefix, so always true
230	public boolean isRelevant(String overrideName) {	238	public boolean isRelevant(String overrideName) {
231	return true;	239	return true;
232	}	240	}
233		241
234	public TextRange getValidationTextRange(CompilationUnit astRoot) {	242	public TextRange getValidationTextRange(CompilationUnit astRoot) {
235	return GenericJavaEmbeddedMapping.this.getValidationTextRange(astRoot);	243	return GenericJavaEmbeddedMapping.this.getValidationTextRange(astRoot);
236	}	244	}
237		245
238	public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {	246	public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {
239	if (override.isVirtual()) {	247	if (override.isVirtual()) {
240	return this.buildVirtualOverrideColumnTableNotValidMessage(override.getName(), column, textRange);	248	return this.buildVirtualOverrideColumnTableNotValidMessage(override.getName(), column, textRange);
Lines 250-256 Link Here
250	textRange	258	textRange
251	);	259	);
252	}	260	}
253		261
254	protected IMessage buildVirtualOverrideColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {	262	protected IMessage buildVirtualOverrideColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
255	return DefaultJpaValidationMessages.buildMessage(	263	return DefaultJpaValidationMessages.buildMessage(
256	IMessage.HIGH_SEVERITY,	264	IMessage.HIGH_SEVERITY,
Lines 264-270 Link Here
264	textRange	272	textRange
265	);	273	);
266	}	274	}
267		275
268	public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {	276	public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {
269	if (override.isVirtual()) {	277	if (override.isVirtual()) {
270	return this.buildVirtualColumnUnresolvedNameMessage(override.getName(), column, textRange);	278	return this.buildVirtualColumnUnresolvedNameMessage(override.getName(), column, textRange);
Lines 277-283 Link Here
277	textRange	285	textRange
278	);	286	);
279	}	287	}
280		288
281	protected IMessage buildVirtualColumnUnresolvedNameMessage(String overrideName, NamedColumn column, TextRange textRange) {	289	protected IMessage buildVirtualColumnUnresolvedNameMessage(String overrideName, NamedColumn column, TextRange textRange) {
282	return DefaultJpaValidationMessages.buildMessage(	290	return DefaultJpaValidationMessages.buildMessage(
283	IMessage.HIGH_SEVERITY,	291	IMessage.HIGH_SEVERITY,
Lines 287-293 Link Here
287	textRange	295	textRange
288	);	296	);
289	}	297	}
290		298
291	public IMessage buildColumnUnresolvedReferencedColumnNameMessage(AssociationOverride override, BaseJoinColumn column, TextRange textRange) {	299	public IMessage buildColumnUnresolvedReferencedColumnNameMessage(AssociationOverride override, BaseJoinColumn column, TextRange textRange) {
292	if (override.isVirtual()) {	300	if (override.isVirtual()) {
293	return this.buildVirtualColumnUnresolvedReferencedColumnNameMessage(override.getName(), column, textRange);	301	return this.buildVirtualColumnUnresolvedReferencedColumnNameMessage(override.getName(), column, textRange);
Lines 300-306 Link Here
300	textRange	308	textRange
301	);	309	);
302	}	310	}
303		311
304	protected IMessage buildVirtualColumnUnresolvedReferencedColumnNameMessage(String overrideName, BaseJoinColumn column, TextRange textRange) {	312	protected IMessage buildVirtualColumnUnresolvedReferencedColumnNameMessage(String overrideName, BaseJoinColumn column, TextRange textRange) {
305	return DefaultJpaValidationMessages.buildMessage(	313	return DefaultJpaValidationMessages.buildMessage(
306	IMessage.HIGH_SEVERITY,	314	IMessage.HIGH_SEVERITY,
Lines 310-316 Link Here
310	textRange	318	textRange
311	);	319	);
312	}	320	}
313		321
314	public IMessage buildUnspecifiedNameMultipleJoinColumnsMessage(AssociationOverride override, BaseJoinColumn column, TextRange textRange) {	322	public IMessage buildUnspecifiedNameMultipleJoinColumnsMessage(AssociationOverride override, BaseJoinColumn column, TextRange textRange) {
315	if (override.isVirtual()) {	323	if (override.isVirtual()) {
316	return this.buildVirtualUnspecifiedNameMultipleJoinColumnsMessage(override.getName(), column, textRange);	324	return this.buildVirtualUnspecifiedNameMultipleJoinColumnsMessage(override.getName(), column, textRange);
Lines 323-329 Link Here
323	textRange	331	textRange
324	);	332	);
325	}	333	}
326		334
327	protected IMessage buildVirtualUnspecifiedNameMultipleJoinColumnsMessage(String overrideName, BaseJoinColumn column, TextRange textRange) {	335	protected IMessage buildVirtualUnspecifiedNameMultipleJoinColumnsMessage(String overrideName, BaseJoinColumn column, TextRange textRange) {
328	return DefaultJpaValidationMessages.buildMessage(	336	return DefaultJpaValidationMessages.buildMessage(
329	IMessage.HIGH_SEVERITY,	337	IMessage.HIGH_SEVERITY,
Lines 333-339 Link Here
333	textRange	341	textRange
334	);	342	);
335	}	343	}
336		344
337	public IMessage buildUnspecifiedReferencedColumnNameMultipleJoinColumnsMessage(AssociationOverride override, BaseJoinColumn column, TextRange textRange) {	345	public IMessage buildUnspecifiedReferencedColumnNameMultipleJoinColumnsMessage(AssociationOverride override, BaseJoinColumn column, TextRange textRange) {
338	if (override.isVirtual()) {	346	if (override.isVirtual()) {
339	return this.buildVirtualUnspecifiedReferencedColumnNameMultipleJoinColumnsMessage(override.getName(), column, textRange);	347	return this.buildVirtualUnspecifiedReferencedColumnNameMultipleJoinColumnsMessage(override.getName(), column, textRange);
Lines 346-352 Link Here
346	textRange	354	textRange
347	);	355	);
348	}	356	}
349		357
350	protected IMessage buildVirtualUnspecifiedReferencedColumnNameMultipleJoinColumnsMessage(String overrideName, BaseJoinColumn column, TextRange textRange) {	358	protected IMessage buildVirtualUnspecifiedReferencedColumnNameMultipleJoinColumnsMessage(String overrideName, BaseJoinColumn column, TextRange textRange) {
351	return DefaultJpaValidationMessages.buildMessage(	359	return DefaultJpaValidationMessages.buildMessage(
352	IMessage.HIGH_SEVERITY,	360	IMessage.HIGH_SEVERITY,




package org.eclipse.jpt.core.internal.context.orm;

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

import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages;
import org.eclipse.jpt.core.internal.validation.JpaValidationDescriptionMessages;
import org.eclipse.jpt.core.internal.validation.JpaValidationMessages;
import org.eclipse.jpt.core.jpa2.context.SingleRelationshipMapping2_0;
import org.eclipse.jpt.core.jpa2.context.orm.OrmCacheableHolder2_0;
import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType;
import org.eclipse.jpt.core.resource.orm.Inheritance;

import org.eclipse.jpt.utility.internal.StringTools;
import org.eclipse.jpt.utility.internal.iterables.CompositeIterable;
import org.eclipse.jpt.utility.internal.iterables.FilteringIterable;
import org.eclipse.jpt.utility.internal.iterables.SubIterableWrapper;
import org.eclipse.jpt.utility.internal.iterables.TransformationIterable;
import org.eclipse.jpt.utility.internal.iterators.CloneIterator;
import org.eclipse.jpt.utility.internal.iterators.CloneListIterator;

		return this.resourceTypeMapping.getInheritanceStrategyTextRange();
	}
		
	class AssociationOverrideContainerOwner
		implements OrmAssociationOverrideContainer.Owner
	{
		public OrmTypeMapping getTypeMapping() {
			return AbstractOrmEntity.this.getTypeMapping();
		}
		
		public TypeMapping getOverridableTypeMapping() {
			return AbstractOrmEntity.this.getOverridableTypeMapping();
		}
		
		public Iterator<String> allOverridableNames() {
			TypeMapping typeMapping = getOverridableTypeMapping();
			return (typeMapping == null) ? 
					EmptyIterator.<String>instance()
					: typeMapping.allOverridableAssociationNames();
		}
		
		public EList<XmlAssociationOverride> getResourceAssociationOverrides() {
			return AbstractOrmEntity.this.resourceTypeMapping.getAssociationOverrides();
		}
		
		public RelationshipReference resolveRelationshipReference(String associationOverrideName) {
			if (!isMetadataComplete()) {
				JavaPersistentType javaPersistentType = getPersistentType().getJavaPersistentType();

		public boolean tableNameIsInvalid(String tableName) {
			return AbstractOrmEntity.this.tableNameIsInvalid(tableName);
		}
		
		public Iterator<String> candidateTableNames() {
			return AbstractOrmEntity.this.associatedTableNamesIncludingInherited();
		}
		
		public org.eclipse.jpt.db.Table getDbTable(String tableName) {
			return AbstractOrmEntity.this.getDbTable(tableName);
		}

		public String getDefaultTableName() {
			return AbstractOrmEntity.this.getPrimaryTableName();
		}
		
		public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {
			if (override.isVirtual()) {
				return this.buildVirtualOverrideColumnTableNotValidMessage(override.getName(), column, textRange);

					textRange
				);
		}
		
		protected IMessage buildVirtualOverrideColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
			);
		}
		
		public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {
			if (override.isVirtual()) {
				return this.buildVirtualColumnUnresolvedNameMessage(override.getName(), column, textRange);

				textRange
			);
		}
		
		protected IMessage buildVirtualColumnUnresolvedNameMessage(String overrideName, NamedColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
			);
		}
		

		public IMessage buildColumnUnresolvedReferencedColumnNameMessage(AssociationOverride override, BaseJoinColumn column, TextRange textRange) {
			if (override.isVirtual()) {
				return this.buildVirtualColumnUnresolvedReferencedColumnNameMessage(override.getName(), column, textRange);

				textRange
			);
		}
		
		protected IMessage buildVirtualUnspecifiedNameMultipleJoinColumnsMessage(String overrideName, BaseJoinColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
			);
		}
		
		public IMessage buildUnspecifiedReferencedColumnNameMultipleJoinColumnsMessage(AssociationOverride override, BaseJoinColumn column, TextRange textRange) {
			if (override.isVirtual()) {
				return this.buildVirtualUnspecifiedReferencedColumnNameMultipleJoinColumnsMessage(override.getName(), column, textRange);

				textRange
			);
		}
		
		protected IMessage buildVirtualUnspecifiedReferencedColumnNameMultipleJoinColumnsMessage(String overrideName, BaseJoinColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

		}
	}
	
	
	//********** OrmAttributeOverrideContainer.Owner implementation *********	
	
	class AttributeOverrideContainerOwner
		implements OrmAttributeOverrideContainer.Owner
	{
		public OrmTypeMapping getTypeMapping() {
			return AbstractOrmEntity.this.getTypeMapping();
		}
		
		public TypeMapping getOverridableTypeMapping() {
			return AbstractOrmEntity.this.getOverridableTypeMapping();
		}
		
		public Iterator<String> allOverridableNames() {
			TypeMapping typeMapping = getOverridableTypeMapping();
			return (typeMapping == null) ? 
					EmptyIterator.<String>instance()
				: allOverridableAttributeNames_(typeMapping);
		}
		
		/* assumes the type mapping is not null */
		protected Iterator allOverridableAttributeNames_(TypeMapping typeMapping) {
			final Collection mappedByRelationshipAttributes = CollectionTools.collection(
					new TransformationIterator<SingleRelationshipMapping2_0, String>(getMapsIdRelationships()) {
						@Override
						protected String transform(SingleRelationshipMapping2_0 next) {
							return next.getDerivedIdentity().getMapsIdDerivedIdentityStrategy().getValue();
						}
					});
			return new FilteringIterator<String>(typeMapping.allOverridableAttributeNames()) {
				@Override
				protected boolean accept(String o) {
					return ! mappedByRelationshipAttributes.contains(o);
				}
			};
		}
		
		protected Iterable<SingleRelationshipMapping2_0> getMapsIdRelationships() {
			return new FilteringIterable<SingleRelationshipMapping2_0>(
					new SubIterableWrapper<AttributeMapping, SingleRelationshipMapping2_0>(
						new CompositeIterable<AttributeMapping>(
							getTypeMapping().getAllAttributeMappings(MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY),
							getTypeMapping().getAllAttributeMappings(MappingKeys.MANY_TO_ONE_ATTRIBUTE_MAPPING_KEY)))) {
				@Override
				protected boolean accept(SingleRelationshipMapping2_0 o) {
					return o.getDerivedIdentity().usesMapsIdDerivedIdentityStrategy();
				}
			};
		}
		
		public EList<XmlAttributeOverride> getResourceAttributeOverrides() {
			return AbstractOrmEntity.this.resourceTypeMapping.getAttributeOverrides();
		}
		
		public Column resolveOverriddenColumn(String attributeOverrideName) {
			if (!isMetadataComplete()) {
				JavaPersistentType javaPersistentType = getPersistentType().getJavaPersistentType();

			}
			return new VirtualXmlColumn(AbstractOrmEntity.this, javaAttributeOverride.getColumn());
		}
		
		public boolean tableNameIsInvalid(String tableName) {
			return AbstractOrmEntity.this.tableNameIsInvalid(tableName);
		}

		public Iterator<String> candidateTableNames() {
			return AbstractOrmEntity.this.associatedTableNamesIncludingInherited();
		}
		
		public org.eclipse.jpt.db.Table getDbTable(String tableName) {
			return AbstractOrmEntity.this.getDbTable(tableName);
		}

		public String getDefaultTableName() {
			return AbstractOrmEntity.this.getPrimaryTableName();
		}
		
		public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {
			if (override.isVirtual()) {
				return this.buildVirtualColumnUnresolvedNameMessage(override.getName(), column, textRange);

				textRange
			);
		}
		
		public IMessage buildVirtualColumnUnresolvedNameMessage(String overrideName, NamedColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
			);
		}
		
		public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {
			if (override.isVirtual()) {
				return this.buildVirtualOverrideColumnTableNotValidMessage(override.getName(), column, textRange);

				textRange
			);
		}
		
		protected IMessage buildVirtualOverrideColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

		}
	}
	
	
	class PrimaryKeyJoinColumnOwner implements OrmBaseJoinColumn.Owner
	{
		public TypeMapping getTypeMapping() {

Lines 12-17 Link Here

(-)src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmIdMapping.java (-34 / +108 lines)
12	import java.util.Iterator;	12	import java.util.Iterator;
13	import java.util.List;	13	import java.util.List;
14	import org.eclipse.jpt.core.MappingKeys;	14	import org.eclipse.jpt.core.MappingKeys;
		15	import org.eclipse.jpt.core.context.AttributeMapping;
15	import org.eclipse.jpt.core.context.BaseColumn;	16	import org.eclipse.jpt.core.context.BaseColumn;
16	import org.eclipse.jpt.core.context.Converter;	17	import org.eclipse.jpt.core.context.Converter;
17	import org.eclipse.jpt.core.context.NamedColumn;	18	import org.eclipse.jpt.core.context.NamedColumn;
Lines 26-31 Link Here
26	import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages;	27	import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages;
27	import org.eclipse.jpt.core.internal.validation.JpaValidationDescriptionMessages;	28	import org.eclipse.jpt.core.internal.validation.JpaValidationDescriptionMessages;
28	import org.eclipse.jpt.core.internal.validation.JpaValidationMessages;	29	import org.eclipse.jpt.core.internal.validation.JpaValidationMessages;
		30	import org.eclipse.jpt.core.jpa2.context.IdMapping2_0;
		31	import org.eclipse.jpt.core.jpa2.context.SingleRelationshipMapping2_0;
29	import org.eclipse.jpt.core.resource.orm.Attributes;	32	import org.eclipse.jpt.core.resource.orm.Attributes;
30	import org.eclipse.jpt.core.resource.orm.OrmFactory;	33	import org.eclipse.jpt.core.resource.orm.OrmFactory;
31	import org.eclipse.jpt.core.resource.orm.XmlColumn;	34	import org.eclipse.jpt.core.resource.orm.XmlColumn;
Lines 33-47 Link Here
33	import org.eclipse.jpt.core.resource.orm.XmlId;	36	import org.eclipse.jpt.core.resource.orm.XmlId;
34	import org.eclipse.jpt.core.utility.TextRange;	37	import org.eclipse.jpt.core.utility.TextRange;
35	import org.eclipse.jpt.db.Table;	38	import org.eclipse.jpt.db.Table;
		39	import org.eclipse.jpt.utility.internal.iterables.CompositeIterable;
		40	import org.eclipse.jpt.utility.internal.iterables.FilteringIterable;
		41	import org.eclipse.jpt.utility.internal.iterables.SubIterableWrapper;
36	import org.eclipse.wst.validation.internal.provisional.core.IMessage;	42	import org.eclipse.wst.validation.internal.provisional.core.IMessage;
37	import org.eclipse.wst.validation.internal.provisional.core.IReporter;	43	import org.eclipse.wst.validation.internal.provisional.core.IReporter;
38		44
39	public abstract class AbstractOrmIdMapping<T extends XmlId>	45	public abstract class AbstractOrmIdMapping<T extends XmlId>
40	extends AbstractOrmAttributeMapping<T>	46	extends AbstractOrmAttributeMapping<T>
41	implements OrmIdMapping	47	implements OrmIdMapping, IdMapping2_0
42	{	48	{
43	protected final OrmColumn column;	49	protected final OrmColumn column;
44		50
		51	/* 2.0 feature - a relationship may map this id */
		52	protected boolean mappedByRelationship;
		53
45	protected OrmGeneratedValue generatedValue;	54	protected OrmGeneratedValue generatedValue;
46		55
47	protected OrmConverter converter;	56	protected OrmConverter converter;
Lines 49-66 Link Here
49	protected final OrmConverter nullConverter;	58	protected final OrmConverter nullConverter;
50		59
51	protected final OrmGeneratorContainer generatorContainer;	60	protected final OrmGeneratorContainer generatorContainer;
52		61
53		62
54	protected AbstractOrmIdMapping(OrmPersistentAttribute parent, T resourceMapping) {	63	protected AbstractOrmIdMapping(OrmPersistentAttribute parent, T resourceMapping) {
55	super(parent, resourceMapping);	64	super(parent, resourceMapping);
56	this.column = getXmlContextNodeFactory().buildOrmColumn(this, this);	65	this.column = getXmlContextNodeFactory().buildOrmColumn(this, this);
57	this.column.initialize(this.resourceAttributeMapping.getColumn());//TODO pass in to constructor	66	this.column.initialize(this.resourceAttributeMapping.getColumn());//TODO pass in to constructor
		67	this.mappedByRelationship = calculateMappedByRelationship();
58	this.generatorContainer = buildGeneratorContainer();	68	this.generatorContainer = buildGeneratorContainer();
59	this.initializeGeneratedValue();	69	this.initializeGeneratedValue();
60	this.nullConverter = this.getXmlContextNodeFactory().buildOrmNullConverter(this);	70	this.nullConverter = this.getXmlContextNodeFactory().buildOrmNullConverter(this);
61	this.converter = this.buildConverter(this.getResourceConverterType());	71	this.converter = this.buildConverter(this.getResourceConverterType());
62	}	72	}
63		73
		74
64	protected OrmGeneratorContainer buildGeneratorContainer() {	75	protected OrmGeneratorContainer buildGeneratorContainer() {
65	return getXmlContextNodeFactory().buildOrmGeneratorContainer(this, this.resourceAttributeMapping);	76	return getXmlContextNodeFactory().buildOrmGeneratorContainer(this, this.resourceAttributeMapping);
66	}	77	}
Lines 68-88 Link Here
68	public String getKey() {	79	public String getKey() {
69	return MappingKeys.ID_ATTRIBUTE_MAPPING_KEY;	80	return MappingKeys.ID_ATTRIBUTE_MAPPING_KEY;
70	}	81	}
71		82
72	public int getXmlSequence() {	83	public int getXmlSequence() {
73	return 0;	84	return 0;
74	}	85	}
75		86
76	public void initializeOn(OrmAttributeMapping newMapping) {	87	public void initializeOn(OrmAttributeMapping newMapping) {
77	newMapping.initializeFromOrmIdMapping(this);	88	newMapping.initializeFromOrmIdMapping(this);
78	}	89	}
79		90
80	@Override	91	@Override
81	public void initializeFromOrmColumnMapping(OrmColumnMapping oldMapping) {	92	public void initializeFromOrmColumnMapping(OrmColumnMapping oldMapping) {
82	super.initializeFromOrmColumnMapping(oldMapping);	93	super.initializeFromOrmColumnMapping(oldMapping);
83	getColumn().initializeFrom(oldMapping.getColumn());	94	getColumn().initializeFrom(oldMapping.getColumn());
84	}	95	}
85
86		96
87	public OrmColumn getColumn() {	97	public OrmColumn getColumn() {
88	return this.column;	98	return this.column;
Lines 118-124 Link Here
118	this.converter = newConverter;	128	this.converter = newConverter;
119	firePropertyChanged(CONVERTER_PROPERTY, oldConverter, newConverter);	129	firePropertyChanged(CONVERTER_PROPERTY, oldConverter, newConverter);
120	}	130	}
121		131
122	public OrmGeneratedValue addGeneratedValue() {	132	public OrmGeneratedValue addGeneratedValue() {
123	if (getGeneratedValue() != null) {	133	if (getGeneratedValue() != null) {
124	throw new IllegalStateException("gemeratedValue already exists"); //$NON-NLS-1$	134	throw new IllegalStateException("gemeratedValue already exists"); //$NON-NLS-1$
Lines 153-164 Link Here
153	public OrmGeneratorContainer getGeneratorContainer() {	163	public OrmGeneratorContainer getGeneratorContainer() {
154	return this.generatorContainer;	164	return this.generatorContainer;
155	}	165	}
156		166
157	@Override	167	@Override
158	public String getPrimaryKeyColumnName() {	168	public String getPrimaryKeyColumnName() {
159	return this.getColumn().getName();	169	return this.getColumn().getName();
160	}	170	}
161		171
162	@Override	172	@Override
163	public boolean isOverridableAttributeMapping() {	173	public boolean isOverridableAttributeMapping() {
164	return true;	174	return true;
Lines 171-201 Link Here
171	public void removeFromResourceModel(Attributes resourceAttributes) {	181	public void removeFromResourceModel(Attributes resourceAttributes) {
172	resourceAttributes.getIds().remove(this.resourceAttributeMapping);	182	resourceAttributes.getIds().remove(this.resourceAttributeMapping);
173	}	183	}
174		184
		185
		186	//*************** XmlColumn.Owner implementation **************
		187
		188	public XmlColumn getResourceColumn() {
		189	return this.resourceAttributeMapping.getColumn();
		190	}
		191
		192	protected boolean isColumnSpecified() {
		193	return ! isVirtual() && getResourceColumn() != null;
		194	}
		195
		196	public void addResourceColumn() {
		197	this.resourceAttributeMapping.setColumn(OrmFactory.eINSTANCE.createXmlColumn());
		198	}
		199
		200	public void removeResourceColumn() {
		201	this.resourceAttributeMapping.setColumn(null);
		202	}
		203
		204
175	//************ NamedColumn.Owner implementation *************	205	//************ NamedColumn.Owner implementation *************
176		206
177	public Table getDbTable(String tableName) {	207	public Table getDbTable(String tableName) {
178	return getTypeMapping().getDbTable(tableName);	208	return getTypeMapping().getDbTable(tableName);
179	}	209	}
180		210
181	public String getDefaultColumnName() {	211	public String getDefaultColumnName() {
182	return getName();	212	return (isMappedByRelationship() && ! isColumnSpecified()) ? null : getName();
183	}	213	}
184		214
		215
185	//************ BaseColumn.Owner implementation *************	216	//************ BaseColumn.Owner implementation *************
186		217
187	public String getDefaultTableName() {	218	public String getDefaultTableName() {
188	return getTypeMapping().getPrimaryTableName();	219	return (isMappedByRelationship() && ! isColumnSpecified()) ? null : getTypeMapping().getPrimaryTableName();
189	}	220	}
190		221
191	public boolean tableNameIsInvalid(String tableName) {	222	public boolean tableNameIsInvalid(String tableName) {
192	return getTypeMapping().tableNameIsInvalid(tableName);	223	return getTypeMapping().tableNameIsInvalid(tableName);
193	}	224	}
194		225
195	public Iterator<String> candidateTableNames() {	226	public Iterator<String> candidateTableNames() {
196	return getTypeMapping().associatedTableNamesIncludingInherited();	227	return getTypeMapping().associatedTableNamesIncludingInherited();
197	}	228	}
198		229
		230
		231	// ************** IdColumn2_0 impl ************************************
		232
		233	public boolean isMappedByRelationship() {
		234	return this.mappedByRelationship;
		235	}
		236
		237	protected void setMappedByRelationship(boolean newValue) {
		238	boolean oldValue = this.mappedByRelationship;
		239	this.mappedByRelationship = newValue;
		240	firePropertyChanged(MAPPED_BY_RELATIONSHIP_PROPERTY, oldValue, newValue);
		241	}
		242
		243	protected boolean calculateMappedByRelationship() {
		244	for (SingleRelationshipMapping2_0 each : getMapsIdRelationships()) {
		245	if (each.getDerivedIdentity().getMapsIdDerivedIdentityStrategy().getResolvedAttributeMappingValue() == this) {
		246	return true;
		247	}
		248	}
		249	return false;
		250	}
		251
		252	protected Iterable<SingleRelationshipMapping2_0> getMapsIdRelationships() {
		253	return new FilteringIterable<SingleRelationshipMapping2_0>(
		254	new SubIterableWrapper<AttributeMapping, SingleRelationshipMapping2_0>(
		255	new CompositeIterable<AttributeMapping>(
		256	getTypeMapping().getAllAttributeMappings(MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY),
		257	getTypeMapping().getAllAttributeMappings(MappingKeys.MANY_TO_ONE_ATTRIBUTE_MAPPING_KEY)))) {
		258	@Override
		259	protected boolean accept(SingleRelationshipMapping2_0 o) {
		260	return o.getDerivedIdentity().usesMapsIdDerivedIdentityStrategy();
		261	}
		262	};
		263	}
		264
		265
199	protected void initializeGeneratedValue() {	266	protected void initializeGeneratedValue() {
200	if (this.resourceAttributeMapping.getGeneratedValue() != null) {	267	if (this.resourceAttributeMapping.getGeneratedValue() != null) {
201	this.generatedValue = buildGeneratedValue(this.resourceAttributeMapping.getGeneratedValue());	268	this.generatedValue = buildGeneratedValue(this.resourceAttributeMapping.getGeneratedValue());
Lines 210-215 Link Here
210	public void update() {	277	public void update() {
211	super.update();	278	super.update();
212	this.column.update(getResourceColumn());	279	this.column.update(getResourceColumn());
		280	setMappedByRelationship(calculateMappedByRelationship());
213	this.generatorContainer.update();	281	this.generatorContainer.update();
214	this.updateGeneratedValue();	282	this.updateGeneratedValue();
215	if (this.valuesAreEqual(getResourceConverterType(), getConverterType())) {	283	if (this.valuesAreEqual(getResourceConverterType(), getConverterType())) {
Lines 220-226 Link Here
220	}	288	}
221	}	289	}
222		290
223
224	protected void updateGeneratedValue() {	291	protected void updateGeneratedValue() {
225	if (this.resourceAttributeMapping.getGeneratedValue() == null) {	292	if (this.resourceAttributeMapping.getGeneratedValue() == null) {
226	if (getGeneratedValue() != null) {	293	if (getGeneratedValue() != null) {
Lines 253-272 Link Here
253	}	320	}
254	return Converter.NO_CONVERTER;	321	return Converter.NO_CONVERTER;
255	}	322	}
256
257	//*************** XmlColumn.Owner implementation **************
258		323
259	public XmlColumn getResourceColumn() {
260	return this.resourceAttributeMapping.getColumn();
261	}
262
263	public void addResourceColumn() {
264	this.resourceAttributeMapping.setColumn(OrmFactory.eINSTANCE.createXmlColumn());
265	}
266
267	public void removeResourceColumn() {
268	this.resourceAttributeMapping.setColumn(null);
269	}
270		324
271	// **************** validation **************	325	// **************** validation **************
272		326
Lines 274-280 Link Here
274	public void validate(List<IMessage> messages, IReporter reporter) {	328	public void validate(List<IMessage> messages, IReporter reporter) {
275	super.validate(messages, reporter);	329	super.validate(messages, reporter);
276		330
277	this.getColumn().validate(messages, reporter);	331	// [JPA 2.0] if the column is specified, or if the id is not mapped by a relationship,
		332	// then the column is validated.
		333	// (In JPA 1.0, the column will always be validated, since the id is never mapped by a
		334	// relationship)
		335	if (isColumnSpecified() \|\| ! isMappedByRelationship()) {
		336	getColumn().validate(messages, reporter);
		337	}
		338
		339	// [JPA 2.0] if the column is specified and the id is mapped by a relationship,
		340	// then that is an error
		341	// (In JPA 1.0, this will never be the case, since the id is never mapped by a relationship)
		342	if (isColumnSpecified() && isMappedByRelationship()) {
		343	messages.add(
		344	DefaultJpaValidationMessages.buildMessage(
		345	IMessage.HIGH_SEVERITY,
		346	JpaValidationMessages.ID_MAPPING_MAPPED_BY_RELATIONSHIP_AND_COLUMN_SPECIFIED,
		347	new String[] {},
		348	getColumn(),
		349	getColumn().getValidationTextRange()));
		350	}
		351
278	if (this.generatedValue != null) {	352	if (this.generatedValue != null) {
279	this.generatedValue.validate(messages, reporter);	353	this.generatedValue.validate(messages, reporter);
280	}	354	}




		}
	}

	class MapKeyAttributeOverrideContainerOwner
		implements OrmAttributeOverrideContainer.Owner
	{
		public OrmTypeMapping getTypeMapping() {
			return AbstractOrmMultiRelationshipMapping.this.getTypeMapping();
		}
		
		public TypeMapping getOverridableTypeMapping() {
			return AbstractOrmMultiRelationshipMapping.this.getResolvedMapKeyEmbeddable();
		}
		
		public Iterator<String> allOverridableNames() {
			TypeMapping typeMapping = getOverridableTypeMapping();
			return (typeMapping == null) ? 
					EmptyIterator.<String>instance()
					: typeMapping.allOverridableAttributeNames();
		}
		
		protected JavaAttributeOverride getJavaAttributeOverrideNamed(String attributeName) {
			return AbstractOrmMultiRelationshipMapping.this.getJavaMapKeyAttributeOverrideNamed(attributeName);
		}
		
		public EList<XmlAttributeOverride> getResourceAttributeOverrides() {
			return AbstractOrmMultiRelationshipMapping.this.resourceAttributeMapping.getMapKeyAttributeOverrides();
		}
		
		public Column resolveOverriddenColumn(String attributeOverrideName) {
			if (getPersistentAttribute().isVirtual() && !getTypeMapping().isMetadataComplete()) {
				JavaAttributeOverride javaAttributeOverride = getJavaAttributeOverrideNamed(attributeOverrideName);

			}
			return MappingTools.resolveOverridenColumn(getOverridableTypeMapping(), attributeOverrideName);
		}
		
		
		public XmlColumn buildVirtualXmlColumn(Column overridableColumn, String attributeName, boolean isMetadataComplete) {
			return new VirtualXmlAttributeOverrideColumn(overridableColumn);
		}
		
		protected OrmJoiningStrategy getPredominantJoiningStrategy() {
			return getRelationshipReference().getPredominantJoiningStrategy();
		}

		public String getDefaultTableName() {
			return getPredominantJoiningStrategy().getTableName();
		}
		
		public Table getDbTable(String tableName) {
			return getPredominantJoiningStrategy().getDbTable(tableName);
		}
		
		public java.util.Iterator<String> candidateTableNames() {
			return EmptyIterator.instance();
		}
		
		/**
		 * If there is a specified table name it needs to be the same
		 * the default table name.  the table is always the collection table

		public boolean tableNameIsInvalid(String tableName) {
			return !StringTools.stringsAreEqual(getDefaultTableName(), tableName);
		}
		
		public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {
			if (isVirtual()) {
				return this.buildVirtualAttributeColumnUnresolvedNameMessage(override.getName(), column, textRange);

				textRange
			);
		}
		
		protected IMessage buildVirtualAttributeColumnUnresolvedNameMessage(String overrideName, NamedColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
			);
		}
		
		protected IMessage buildVirtualOverrideColumnUnresolvedNameMessage(String overrideName, NamedColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
			);
		}
		
		public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {
			if (isVirtual()) {
				return this.buildVirtualAttributeColumnTableNotValidMessage(override.getName(), column, textRange);

					textRange
				);
		}
		
		protected IMessage buildVirtualAttributeColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
			);
		}
		
		protected IMessage buildVirtualOverrideColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
			);
		}
		
		public TextRange getValidationTextRange() {
			return AbstractOrmMultiRelationshipMapping.this.getValidationTextRange();
		}

Lines 43-63 Link Here

(-)src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmBaseEmbeddedMapping.java (-21 / +43 lines)
43	import org.eclipse.wst.validation.internal.provisional.core.IReporter;	43	import org.eclipse.wst.validation.internal.provisional.core.IReporter;
44		44
45		45
46	public abstract class AbstractOrmBaseEmbeddedMapping<T extends AbstractXmlEmbedded> extends AbstractOrmAttributeMapping<T> implements OrmBaseEmbeddedMapping	46	public abstract class AbstractOrmBaseEmbeddedMapping<T extends AbstractXmlEmbedded>
		47	extends AbstractOrmAttributeMapping<T>
		48	implements OrmBaseEmbeddedMapping
47	{	49	{
48	protected OrmAttributeOverrideContainer attributeOverrideContainer;	50	protected OrmAttributeOverrideContainer attributeOverrideContainer;
49		51
50	private Embeddable targetEmbeddable;//TODO hmm, why no property change notification for setting this??	52	private Embeddable targetEmbeddable;
		53
51		54
52	protected AbstractOrmBaseEmbeddedMapping(OrmPersistentAttribute parent, T resourceMapping) {	55	protected AbstractOrmBaseEmbeddedMapping(OrmPersistentAttribute parent, T resourceMapping) {
53	super(parent, resourceMapping);	56	super(parent, resourceMapping);
54	this.targetEmbeddable = embeddableFor(this.getJavaPersistentAttribute());	57	this.targetEmbeddable = embeddableFor(this.getJavaPersistentAttribute());
55	this.attributeOverrideContainer =	58	this.attributeOverrideContainer
56	getXmlContextNodeFactory().buildOrmAttributeOverrideContainer(	59	= getXmlContextNodeFactory().buildOrmAttributeOverrideContainer(
57	this,	60	this,
58	new AttributeOverrideContainerOwner());	61	buildAttributeOverrideContainerOwner());
59	}	62	}
60		63
		64
		65	protected OrmAttributeOverrideContainer.Owner buildAttributeOverrideContainerOwner() {
		66	return new AttributeOverrideContainerOwner();
		67	}
		68
61	@Override	69	@Override
62	public void initializeFromOrmBaseEmbeddedMapping(OrmBaseEmbeddedMapping oldMapping) {	70	public void initializeFromOrmBaseEmbeddedMapping(OrmBaseEmbeddedMapping oldMapping) {
63	super.initializeFromOrmBaseEmbeddedMapping(oldMapping);	71	super.initializeFromOrmBaseEmbeddedMapping(oldMapping);
Lines 213-230 Link Here
213		221
214	//******** AttributeOverrideContainer.Owner implementation *******	222	//******** AttributeOverrideContainer.Owner implementation *******
215		223
216	class AttributeOverrideContainerOwner implements OrmAttributeOverrideContainer.Owner {	224	protected class AttributeOverrideContainerOwner
		225	implements OrmAttributeOverrideContainer.Owner
		226	{
		227	public OrmTypeMapping getTypeMapping() {
		228	return AbstractOrmBaseEmbeddedMapping.this.getTypeMapping();
		229	}
		230
217	public TypeMapping getOverridableTypeMapping() {	231	public TypeMapping getOverridableTypeMapping() {
218	return AbstractOrmBaseEmbeddedMapping.this.getTargetEmbeddable();	232	return AbstractOrmBaseEmbeddedMapping.this.getTargetEmbeddable();
219	}	233	}
220		234
		235	public Iterator<String> allOverridableNames() {
		236	TypeMapping typeMapping = getOverridableTypeMapping();
		237	return (typeMapping == null) ?
		238	EmptyIterator.<String>instance()
		239	: allOverridableAttributeNames_(typeMapping);
		240	}
		241
		242	/* assumes the type mapping is not null */
		243	protected Iterator<String> allOverridableAttributeNames_(TypeMapping typeMapping) {
		244	return typeMapping.allOverridableAttributeNames();
		245	}
		246
221	public EList<XmlAttributeOverride> getResourceAttributeOverrides() {	247	public EList<XmlAttributeOverride> getResourceAttributeOverrides() {
222	return AbstractOrmBaseEmbeddedMapping.this.resourceAttributeMapping.getAttributeOverrides();	248	return AbstractOrmBaseEmbeddedMapping.this.resourceAttributeMapping.getAttributeOverrides();
223	}	249	}
224
225	public OrmTypeMapping getTypeMapping() {
226	return AbstractOrmBaseEmbeddedMapping.this.getTypeMapping();
227	}
228		250
229	public Column resolveOverriddenColumn(String attributeOverrideName) {	251	public Column resolveOverriddenColumn(String attributeOverrideName) {
230	if (getPersistentAttribute().isVirtual() && !getTypeMapping().isMetadataComplete()) {	252	if (getPersistentAttribute().isVirtual() && !getTypeMapping().isMetadataComplete()) {
Lines 247-253 Link Here
247	public Iterator<String> candidateTableNames() {	269	public Iterator<String> candidateTableNames() {
248	return getTypeMapping().associatedTableNamesIncludingInherited();	270	return getTypeMapping().associatedTableNamesIncludingInherited();
249	}	271	}
250		272
251	public org.eclipse.jpt.db.Table getDbTable(String tableName) {	273	public org.eclipse.jpt.db.Table getDbTable(String tableName) {
252	return getTypeMapping().getDbTable(tableName);	274	return getTypeMapping().getDbTable(tableName);
253	}	275	}
Lines 255-261 Link Here
255	public String getDefaultTableName() {	277	public String getDefaultTableName() {
256	return getTypeMapping().getPrimaryTableName();	278	return getTypeMapping().getPrimaryTableName();
257	}	279	}
258		280
259	public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {	281	public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {
260	if (isVirtual()) {	282	if (isVirtual()) {
261	return this.buildVirtualAttributeUnresolvedColumnTableNotValidMessage(override.getName(), column, textRange);	283	return this.buildVirtualAttributeUnresolvedColumnTableNotValidMessage(override.getName(), column, textRange);
Lines 271-277 Link Here
271	textRange	293	textRange
272	);	294	);
273	}	295	}
274		296
275	protected IMessage buildVirtualAttributeUnresolvedColumnTableNotValidMessage(String overrideName, NamedColumn column, TextRange textRange) {	297	protected IMessage buildVirtualAttributeUnresolvedColumnTableNotValidMessage(String overrideName, NamedColumn column, TextRange textRange) {
276	return DefaultJpaValidationMessages.buildMessage(	298	return DefaultJpaValidationMessages.buildMessage(
277	IMessage.HIGH_SEVERITY,	299	IMessage.HIGH_SEVERITY,
Lines 298-304 Link Here
298	textRange	320	textRange
299	);	321	);
300	}	322	}
301		323
302	public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {	324	public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {
303	if (isVirtual()) {	325	if (isVirtual()) {
304	return this.buildVirtualAttributeColumnTableNotValidMessage(override.getName(), column, textRange);	326	return this.buildVirtualAttributeColumnTableNotValidMessage(override.getName(), column, textRange);
Lines 317-323 Link Here
317	textRange	339	textRange
318	);	340	);
319	}	341	}
320		342
321	protected IMessage buildVirtualAttributeColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {	343	protected IMessage buildVirtualAttributeColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
322	return DefaultJpaValidationMessages.buildMessage(	344	return DefaultJpaValidationMessages.buildMessage(
323	IMessage.HIGH_SEVERITY,	345	IMessage.HIGH_SEVERITY,
Lines 332-338 Link Here
332	textRange	354	textRange
333	);	355	);
334	}	356	}
335		357
336	protected IMessage buildVirtualOverrideColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {	358	protected IMessage buildVirtualOverrideColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
337	return DefaultJpaValidationMessages.buildMessage(	359	return DefaultJpaValidationMessages.buildMessage(
338	IMessage.HIGH_SEVERITY,	360	IMessage.HIGH_SEVERITY,
Lines 346-352 Link Here
346	textRange	368	textRange
347	);	369	);
348	}	370	}
349		371
350	public TextRange getValidationTextRange() {	372	public TextRange getValidationTextRange() {
351	return AbstractOrmBaseEmbeddedMapping.this.getValidationTextRange();	373	return AbstractOrmBaseEmbeddedMapping.this.getValidationTextRange();
352	}	374	}




import org.eclipse.jpt.core.resource.java.AttributeOverrideAnnotation;

/**
 * 
 * 
 * Provisional API: This interface is part of an interim API that is still
 * under development and expected to change significantly before reaching
 * stability. It is available at this early stage to solicit feedback from

	JavaAttributeOverride setVirtual(boolean virtual);
	
	AttributeOverrideAnnotation getOverrideAnnotation();
	
	void initialize(AttributeOverrideAnnotation attributeOverride);
	
	/**

	 * resource model object. see {@link org.eclipse.jpt.core.JpaProject#update()}
	 */
	void update(AttributeOverrideAnnotation attributeOverride);
	
	interface Owner
		extends AttributeOverride.Owner, JavaOverride.Owner
	{
		//nothing yet
	}

Lines 14-19 Link Here

(-)src/org/eclipse/jpt/core/internal/context/java/AbstractJavaIdMapping.java (-25 / +103 lines)
14	import java.util.Vector;	14	import java.util.Vector;
15	import org.eclipse.jdt.core.dom.CompilationUnit;	15	import org.eclipse.jdt.core.dom.CompilationUnit;
16	import org.eclipse.jpt.core.MappingKeys;	16	import org.eclipse.jpt.core.MappingKeys;
		17	import org.eclipse.jpt.core.context.AttributeMapping;
17	import org.eclipse.jpt.core.context.BaseColumn;	18	import org.eclipse.jpt.core.context.BaseColumn;
18	import org.eclipse.jpt.core.context.Converter;	19	import org.eclipse.jpt.core.context.Converter;
19	import org.eclipse.jpt.core.context.NamedColumn;	20	import org.eclipse.jpt.core.context.NamedColumn;
Lines 26-31 Link Here
26	import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages;	27	import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages;
27	import org.eclipse.jpt.core.internal.validation.JpaValidationDescriptionMessages;	28	import org.eclipse.jpt.core.internal.validation.JpaValidationDescriptionMessages;
28	import org.eclipse.jpt.core.internal.validation.JpaValidationMessages;	29	import org.eclipse.jpt.core.internal.validation.JpaValidationMessages;
		30	import org.eclipse.jpt.core.jpa2.context.IdMapping2_0;
		31	import org.eclipse.jpt.core.jpa2.context.SingleRelationshipMapping2_0;
29	import org.eclipse.jpt.core.resource.java.ColumnAnnotation;	32	import org.eclipse.jpt.core.resource.java.ColumnAnnotation;
30	import org.eclipse.jpt.core.resource.java.GeneratedValueAnnotation;	33	import org.eclipse.jpt.core.resource.java.GeneratedValueAnnotation;
31	import org.eclipse.jpt.core.resource.java.IdAnnotation;	34	import org.eclipse.jpt.core.resource.java.IdAnnotation;
Lines 37-42 Link Here
37	import org.eclipse.jpt.utility.Filter;	40	import org.eclipse.jpt.utility.Filter;
38	import org.eclipse.jpt.utility.internal.CollectionTools;	41	import org.eclipse.jpt.utility.internal.CollectionTools;
39	import org.eclipse.jpt.utility.internal.StringTools;	42	import org.eclipse.jpt.utility.internal.StringTools;
		43	import org.eclipse.jpt.utility.internal.iterables.CompositeIterable;
		44	import org.eclipse.jpt.utility.internal.iterables.FilteringIterable;
		45	import org.eclipse.jpt.utility.internal.iterables.SubIterableWrapper;
40	import org.eclipse.jpt.utility.internal.iterators.EmptyIterator;	46	import org.eclipse.jpt.utility.internal.iterators.EmptyIterator;
41	import org.eclipse.jpt.utility.internal.iterators.FilteringIterator;	47	import org.eclipse.jpt.utility.internal.iterators.FilteringIterator;
42	import org.eclipse.wst.validation.internal.provisional.core.IMessage;	48	import org.eclipse.wst.validation.internal.provisional.core.IMessage;
Lines 45-56 Link Here
45		51
46	public abstract class AbstractJavaIdMapping	52	public abstract class AbstractJavaIdMapping
47	extends AbstractJavaAttributeMapping<IdAnnotation>	53	extends AbstractJavaAttributeMapping<IdAnnotation>
48	implements JavaIdMapping	54	implements JavaIdMapping, IdMapping2_0
49	{	55	{
50	protected final JavaColumn column;	56	protected final JavaColumn column;
51		57
		58	/* 2.0 feature - a relationship may map this id */
		59	protected boolean mappedByRelationship;
		60
52	protected JavaGeneratedValue generatedValue;	61	protected JavaGeneratedValue generatedValue;
53		62
54	protected final JavaGeneratorContainer generatorContainer;	63	protected final JavaGeneratorContainer generatorContainer;
55		64
56	protected JavaConverter converter;	65	protected JavaConverter converter;
Lines 65-102 Link Here
65	this.nullConverter = getJpaFactory().buildJavaNullConverter(this);	74	this.nullConverter = getJpaFactory().buildJavaNullConverter(this);
66	this.converter = this.nullConverter;	75	this.converter = this.nullConverter;
67	}	76	}
68		77
		78
69	@Override	79	@Override
70	protected void initialize() {	80	protected void initialize() {
71	super.initialize();	81	super.initialize();
72	this.column.initialize(this.getResourceColumn());	82	this.column.initialize(this.getResourceColumn());
		83	this.mappedByRelationship = calculateMappedByRelationship();
73	this.generatorContainer.initialize(this.getResourcePersistentAttribute());	84	this.generatorContainer.initialize(this.getResourcePersistentAttribute());
74	this.initializeGeneratedValue();	85	this.initializeGeneratedValue();
75	this.converter = this.buildConverter(this.getResourceConverterType());	86	this.converter = this.buildConverter(this.getResourceConverterType());
76	}	87	}
77		88
78	protected void initializeGeneratedValue() {	89	protected void initializeGeneratedValue() {
79	GeneratedValueAnnotation resourceGeneratedValue = this.getResourceGeneratedValue();	90	GeneratedValueAnnotation resourceGeneratedValue = this.getResourceGeneratedValue();
80	if (resourceGeneratedValue != null) {	91	if (resourceGeneratedValue != null) {
81	this.generatedValue = this.buildGeneratedValue(resourceGeneratedValue);	92	this.generatedValue = this.buildGeneratedValue(resourceGeneratedValue);
82	}	93	}
83	}	94	}
84		95
85	public ColumnAnnotation getResourceColumn() {	96	public ColumnAnnotation getResourceColumn() {
86	return (ColumnAnnotation) this.getResourcePersistentAttribute().	97	return (ColumnAnnotation) this.getResourcePersistentAttribute().
87	getNonNullAnnotation(ColumnAnnotation.ANNOTATION_NAME);	98	getNonNullAnnotation(ColumnAnnotation.ANNOTATION_NAME);
88	}	99	}
89		100
		101	protected boolean isColumnSpecified() {
		102	return getResourcePersistentAttribute().getAnnotation(ColumnAnnotation.ANNOTATION_NAME) != null;
		103	}
		104
90	private JavaGeneratorContainer buildGeneratorContainer() {	105	private JavaGeneratorContainer buildGeneratorContainer() {
91	return this.getJpaFactory().buildJavaGeneratorContainer(this);	106	return this.getJpaFactory().buildJavaGeneratorContainer(this);
92	}	107	}
93		108
		109
94	//************ JavaAttributeMapping implementation *************	110	//************ JavaAttributeMapping implementation *************
95		111
96	public String getKey() {	112	public String getKey() {
97	return MappingKeys.ID_ATTRIBUTE_MAPPING_KEY;	113	return MappingKeys.ID_ATTRIBUTE_MAPPING_KEY;
98	}	114	}
99		115
100	public String getAnnotationName() {	116	public String getAnnotationName() {
101	return IdAnnotation.ANNOTATION_NAME;	117	return IdAnnotation.ANNOTATION_NAME;
102	}	118	}
Lines 111-136 Link Here
111	names.add(JPA.SEQUENCE_GENERATOR);	127	names.add(JPA.SEQUENCE_GENERATOR);
112	}	128	}
113		129
		130
114	//************ NamedColumn.Owner implementation *************	131	//************ NamedColumn.Owner implementation *************
115		132
116	public String getDefaultColumnName() {	133	public String getDefaultColumnName() {
117	return getName();	134	return (isMappedByRelationship() && ! isColumnSpecified()) ? null : getName();
118	}	135	}
119		136
		137
120	//************ BaseColumn.Owner implementation *************	138	//************ BaseColumn.Owner implementation *************
121		139
122	public String getDefaultTableName() {	140	public String getDefaultTableName() {
123	return getTypeMapping().getPrimaryTableName();	141	return (isMappedByRelationship() && ! isColumnSpecified()) ? null : getTypeMapping().getPrimaryTableName();
124	}	142	}
125		143
126	public boolean tableNameIsInvalid(String tableName) {	144	public boolean tableNameIsInvalid(String tableName) {
127	return getTypeMapping().tableNameIsInvalid(tableName);	145	return getTypeMapping().tableNameIsInvalid(tableName);
128	}	146	}
129		147
130	public Iterator<String> candidateTableNames() {	148	public Iterator<String> candidateTableNames() {
131	return getTypeMapping().associatedTableNamesIncludingInherited();	149	return getTypeMapping().associatedTableNamesIncludingInherited();
132	}	150	}
133		151
		152
134	//************ IdMapping implementation *************	153	//************ IdMapping implementation *************
135		154
136	public JavaColumn getColumn() {	155	public JavaColumn getColumn() {
Lines 209-214 Link Here
209	protected void update() {	228	protected void update() {
210	super.update();	229	super.update();
211	this.column.update(this.getResourceColumn());	230	this.column.update(this.getResourceColumn());
		231	setMappedByRelationship(calculateMappedByRelationship());
212	this.generatorContainer.update(this.getResourcePersistentAttribute());	232	this.generatorContainer.update(this.getResourcePersistentAttribute());
213	this.updateGeneratedValue();	233	this.updateGeneratedValue();
214	if (this.valuesAreEqual(getResourceConverterType(), getConverterType())) {	234	if (this.valuesAreEqual(getResourceConverterType(), getConverterType())) {
Lines 219-225 Link Here
219	setConverter(javaConverter);	239	setConverter(javaConverter);
220	}	240	}
221	}	241	}
222		242
223	protected void updateGeneratedValue() {	243	protected void updateGeneratedValue() {
224	GeneratedValueAnnotation resourceGeneratedValue = getResourceGeneratedValue();	244	GeneratedValueAnnotation resourceGeneratedValue = getResourceGeneratedValue();
225	if (resourceGeneratedValue == null) {	245	if (resourceGeneratedValue == null) {
Lines 242-248 Link Here
242	gv.initialize(resourceGeneratedValue);	262	gv.initialize(resourceGeneratedValue);
243	return gv;	263	return gv;
244	}	264	}
245		265
246	protected TableGeneratorAnnotation getResourceTableGenerator() {	266	protected TableGeneratorAnnotation getResourceTableGenerator() {
247	return (TableGeneratorAnnotation) this.getResourcePersistentAttribute().	267	return (TableGeneratorAnnotation) this.getResourcePersistentAttribute().
248	getAnnotation(TableGeneratorAnnotation.ANNOTATION_NAME);	268	getAnnotation(TableGeneratorAnnotation.ANNOTATION_NAME);
Lines 274-282 Link Here
274	}	294	}
275	return Converter.NO_CONVERTER;	295	return Converter.NO_CONVERTER;
276	}	296	}
277		297
		298
		299	// ************** IdMapping2_0 impl ***********************************
		300
		301	public boolean isMappedByRelationship() {
		302	return this.mappedByRelationship;
		303	}
		304
		305	protected void setMappedByRelationship(boolean newValue) {
		306	boolean oldValue = this.mappedByRelationship;
		307	this.mappedByRelationship = newValue;
		308	firePropertyChanged(MAPPED_BY_RELATIONSHIP_PROPERTY, oldValue, newValue);
		309	}
		310
		311	protected boolean calculateMappedByRelationship() {
		312	for (SingleRelationshipMapping2_0 each : getMapsIdRelationships()) {
		313	if (getName().equals(each.getDerivedIdentity().getMapsIdDerivedIdentityStrategy().getValue())) {
		314	return true;
		315	}
		316	}
		317	return false;
		318	}
		319
		320	protected Iterable<SingleRelationshipMapping2_0> getMapsIdRelationships() {
		321	return new FilteringIterable<SingleRelationshipMapping2_0>(
		322	new SubIterableWrapper<AttributeMapping, SingleRelationshipMapping2_0>(
		323	new CompositeIterable<AttributeMapping>(
		324	getTypeMapping().getAllAttributeMappings(MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY),
		325	getTypeMapping().getAllAttributeMappings(MappingKeys.MANY_TO_ONE_ATTRIBUTE_MAPPING_KEY)))) {
		326	@Override
		327	protected boolean accept(SingleRelationshipMapping2_0 o) {
		328	return o.getDerivedIdentity().usesMapsIdDerivedIdentityStrategy();
		329	}
		330	};
		331	}
		332
		333
278	// ******** code assist ********	334	// ******** code assist ********
279		335
280	@Override	336	@Override
281	public Iterator<String> javaCompletionProposals(int pos, Filter<String> filter, CompilationUnit astRoot) {	337	public Iterator<String> javaCompletionProposals(int pos, Filter<String> filter, CompilationUnit astRoot) {
282	Iterator<String> result = super.javaCompletionProposals(pos, filter, astRoot);	338	Iterator<String> result = super.javaCompletionProposals(pos, filter, astRoot);
Lines 303-309 Link Here
303	}	359	}
304	return null;	360	return null;
305	}	361	}
306		362
		363
307	// ********** code assist: generator	364	// ********** code assist: generator
308		365
309	protected boolean generatorTouches(int pos, CompilationUnit astRoot) {	366	protected boolean generatorTouches(int pos, CompilationUnit astRoot) {
Lines 327-360 Link Here
327	protected Iterator<String> persistenceGeneratorNames(Filter<String> filter) {	384	protected Iterator<String> persistenceGeneratorNames(Filter<String> filter) {
328	return StringTools.convertToJavaStringLiterals(this.generatorNames(filter));	385	return StringTools.convertToJavaStringLiterals(this.generatorNames(filter));
329	}	386	}
330		387
		388
331	// *************************************************************************	389	// *************************************************************************
332		390
333	@Override	391	@Override
334	public String getPrimaryKeyColumnName() {	392	public String getPrimaryKeyColumnName() {
335	return this.getColumn().getName();	393	return this.getColumn().getName();
336	}	394	}
337		395
338	@Override	396	@Override
339	public boolean isOverridableAttributeMapping() {	397	public boolean isOverridableAttributeMapping() {
340	return true;	398	return true;
341	}	399	}
342		400
343		401
344	//********* Validation **********	402	//********* Validation **********
345		403
346	@Override	404	@Override
347	public void validate(List<IMessage> messages, IReporter reporter, CompilationUnit astRoot) {	405	public void validate(List<IMessage> messages, IReporter reporter, CompilationUnit astRoot) {
348	super.validate(messages, reporter, astRoot);	406	super.validate(messages, reporter, astRoot);
349		407
350	this.getColumn().validate(messages, reporter, astRoot);	408	// [JPA 2.0] if the column is specified, or if the id is not mapped by a relationship,
		409	// then the column is validated.
		410	// (In JPA 1.0, the column will always be validated, since the id is never mapped by a
		411	// relationship)
		412	if (isColumnSpecified() \|\| ! isMappedByRelationship()) {
		413	this.getColumn().validate(messages, reporter, astRoot);
		414	}
		415
		416	// [JPA 2.0] if the column is specified and the id is mapped by a relationship,
		417	// then that is an error
		418	// (In JPA 1.0, this will never be the case, since the id is never mapped by a relationship)
		419	if (isColumnSpecified() && isMappedByRelationship()) {
		420	messages.add(
		421	DefaultJpaValidationMessages.buildMessage(
		422	IMessage.HIGH_SEVERITY,
		423	JpaValidationMessages.ID_MAPPING_MAPPED_BY_RELATIONSHIP_AND_COLUMN_SPECIFIED,
		424	new String[] {},
		425	getColumn(),
		426	getColumn().getValidationTextRange(astRoot)));
		427	}
		428
351	if (this.getGeneratedValue() != null) {	429	if (this.getGeneratedValue() != null) {
352	this.getGeneratedValue().validate(messages, reporter, astRoot);	430	this.getGeneratedValue().validate(messages, reporter, astRoot);
353	}	431	}
354	this.getGeneratorContainer().validate(messages, reporter, astRoot);	432	this.getGeneratorContainer().validate(messages, reporter, astRoot);
355	this.getConverter().validate(messages, reporter, astRoot);	433	this.getConverter().validate(messages, reporter, astRoot);
356	}	434	}
357		435
358	public IMessage buildTableNotValidMessage(BaseColumn column, TextRange textRange) {	436	public IMessage buildTableNotValidMessage(BaseColumn column, TextRange textRange) {
359	return DefaultJpaValidationMessages.buildMessage(	437	return DefaultJpaValidationMessages.buildMessage(
360	IMessage.HIGH_SEVERITY,	438	IMessage.HIGH_SEVERITY,
Lines 367-373 Link Here
367	textRange	445	textRange
368	);	446	);
369	}	447	}
370		448
371	public IMessage buildUnresolvedNameMessage(NamedColumn column, TextRange textRange) {	449	public IMessage buildUnresolvedNameMessage(NamedColumn column, TextRange textRange) {
372	return DefaultJpaValidationMessages.buildMessage(	450	return DefaultJpaValidationMessages.buildMessage(
373	IMessage.HIGH_SEVERITY,	451	IMessage.HIGH_SEVERITY,




		extends OverrideContainerOwner
		implements JavaAttributeOverrideContainer.Owner
	{
		public TypeMapping getOverridableTypeMapping() {
			return AbstractJavaMultiRelationshipMapping.this.getResolvedMapKeyEmbeddable();
		}
		
		public Iterator<String> allOverridableNames() {
			TypeMapping typeMapping = getOverridableTypeMapping();
			return (typeMapping == null) ? 
					EmptyIterator.<String>instance()
					: typeMapping.allOverridableAttributeNames();
		}
		
		public String getPossiblePrefix() {
			return "key."; //$NON-NLS-1$
		}
		
		public String getWritePrefix() {
			return this.getPossiblePrefix();
		}
		
		//since only the key can be an embeddable on a 1-m or m-m, all overrides are relevant
		public boolean isRelevant(String overrideName) {
			return true;
		}
		
		public TypeMapping getOverridableTypeMapping() {
			return AbstractJavaMultiRelationshipMapping.this.getResolvedMapKeyEmbeddable();
		}
	
		public Column resolveOverriddenColumn(String attributeOverrideName) {
			return MappingTools.resolveOverridenColumn(getOverridableTypeMapping(), attributeOverrideName);
		}
		
		public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {
			if (override.isVirtual()) {
				return this.buildVirtualColumnUnresolvedNameMessage(override.getName(), column, textRange);

				textRange
			);
		}
		
		public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {
			if (override.isVirtual()) {
				return this.buildVirtualColumnTableNotValidMessage(override.getName(), column, textRange);

				textRange
			);
		}
		
		protected IMessage buildVirtualColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,




package org.eclipse.jpt.core.internal.context.java;

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

import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages;
import org.eclipse.jpt.core.internal.validation.JpaValidationDescriptionMessages;
import org.eclipse.jpt.core.internal.validation.JpaValidationMessages;
import org.eclipse.jpt.core.jpa2.context.SingleRelationshipMapping2_0;
import org.eclipse.jpt.core.jpa2.context.java.JavaCacheableHolder2_0;
import org.eclipse.jpt.core.resource.java.DiscriminatorColumnAnnotation;
import org.eclipse.jpt.core.resource.java.DiscriminatorValueAnnotation;

import org.eclipse.jpt.utility.internal.iterables.ArrayIterable;
import org.eclipse.jpt.utility.internal.iterables.CompositeIterable;
import org.eclipse.jpt.utility.internal.iterables.FilteringIterable;
import org.eclipse.jpt.utility.internal.iterables.SubIterableWrapper;
import org.eclipse.jpt.utility.internal.iterables.TransformationIterable;
import org.eclipse.jpt.utility.internal.iterators.CloneListIterator;
import org.eclipse.jpt.utility.internal.iterators.CompositeIterator;

	
	// ********** association override container owner **********

	class AssociationOverrideContainerOwner
		implements JavaAssociationOverrideContainer.Owner
	{	
		public TypeMapping getTypeMapping() {
			return AbstractJavaEntity.this.getTypeMapping();
		}
		
		public TypeMapping getOverridableTypeMapping() {
			return AbstractJavaEntity.this.getOverridableTypeMapping();
		}
		
		public Iterator<String> allOverridableNames() {
			TypeMapping typeMapping = getOverridableTypeMapping();
			return (typeMapping == null) ? 
					EmptyIterator.<String>instance()
					: typeMapping.allOverridableAssociationNames();
		}
		
		public RelationshipReference resolveRelationshipReference(String associationOverrideName) {
			return MappingTools.resolveRelationshipReference(getOverridableTypeMapping(), associationOverrideName);
		}

		public Iterator<String> candidateTableNames() {
			return AbstractJavaEntity.this.associatedTableNamesIncludingInherited();
		}
		
		public org.eclipse.jpt.db.Table getDbTable(String tableName) {
			return AbstractJavaEntity.this.getDbTable(tableName);
		}

		public String getDefaultTableName() {
			return AbstractJavaEntity.this.getPrimaryTableName();
		}
		
		public String getPossiblePrefix() {
			return null;
		}
		
		public String getWritePrefix() {
			return null;
		}
		
		public boolean isRelevant(String overrideName) {
			//no prefix, so always true
			return true;
		}
		
		public TextRange getValidationTextRange(CompilationUnit astRoot) {
			return AbstractJavaEntity.this.getValidationTextRange(astRoot);
		}
		
		public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {
			if (override.isVirtual()) {
				return this.buildVirtualOverrideColumnTableNotValidMessage(override.getName(), column, textRange);

				textRange
			);
		}
		
		protected IMessage buildVirtualOverrideColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
			);
		}
		
		public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {
			if (override.isVirtual()) {
				return this.buildVirtualColumnUnresolvedNameMessage(override.getName(), column, textRange);

				textRange
			);
		}
		
		public IMessage buildColumnUnresolvedReferencedColumnNameMessage(AssociationOverride override, BaseJoinColumn column, TextRange textRange) {
			if (override.isVirtual()) {
				return this.buildVirtualColumnUnresolvedReferencedColumnNameMessage(override.getName(), column, textRange);

				textRange
			);
		}
		
		public IMessage buildUnspecifiedNameMultipleJoinColumnsMessage(AssociationOverride override, BaseJoinColumn column, TextRange textRange) {
			if (override.isVirtual()) {
				return this.buildVirtualUnspecifiedNameMultipleJoinColumnsMessage(override.getName(), column, textRange);

				textRange
			);
		}
		
		protected IMessage buildVirtualUnspecifiedNameMultipleJoinColumnsMessage(String overrideName, BaseJoinColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
			);
		}
		
		protected IMessage buildVirtualUnspecifiedReferencedColumnNameMultipleJoinColumnsMessage(String overrideName, BaseJoinColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

	
	//********** AttributeOverrideContainer.Owner implementation *********	
	
	class AttributeOverrideContainerOwner
		implements JavaAttributeOverrideContainer.Owner 
	{
		public TypeMapping getTypeMapping() {
			return AbstractJavaEntity.this.getTypeMapping();
		}
		
		public TypeMapping getOverridableTypeMapping() {
			return AbstractJavaEntity.this.getOverridableTypeMapping();
		}
		
		public Iterator<String> allOverridableNames() {
			TypeMapping typeMapping = getOverridableTypeMapping();
			return (typeMapping == null) ? 
					EmptyIterator.<String>instance()
				: allOverridableAttributeNames_(typeMapping);
		}
		
		/* assumes the type mapping is not null */
		protected Iterator allOverridableAttributeNames_(TypeMapping typeMapping) {
			final Collection mappedByRelationshipAttributes = CollectionTools.collection(
					new TransformationIterator<SingleRelationshipMapping2_0, String>(getMapsIdRelationships()) {
						@Override
						protected String transform(SingleRelationshipMapping2_0 next) {
							return next.getDerivedIdentity().getMapsIdDerivedIdentityStrategy().getValue();
						}
					});
			return new FilteringIterator<String>(typeMapping.allOverridableAttributeNames()) {
				@Override
				protected boolean accept(String o) {
					return ! mappedByRelationshipAttributes.contains(o);
				}
			};
		}
		
		protected Iterable<SingleRelationshipMapping2_0> getMapsIdRelationships() {
			return new FilteringIterable<SingleRelationshipMapping2_0>(
					new SubIterableWrapper<AttributeMapping, SingleRelationshipMapping2_0>(
						new CompositeIterable<AttributeMapping>(
							getTypeMapping().getAllAttributeMappings(MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY),
							getTypeMapping().getAllAttributeMappings(MappingKeys.MANY_TO_ONE_ATTRIBUTE_MAPPING_KEY)))) {
				@Override
				protected boolean accept(SingleRelationshipMapping2_0 o) {
					return o.getDerivedIdentity().usesMapsIdDerivedIdentityStrategy();
				}
			};
		}
		
		public Column resolveOverriddenColumn(String attributeOverrideName) {
			return MappingTools.resolveOverridenColumn(getOverridableTypeMapping(), attributeOverrideName);
		}

		public boolean tableNameIsInvalid(String tableName) {
			return AbstractJavaEntity.this.tableNameIsInvalid(tableName);
		}
		
		public Iterator<String> candidateTableNames() {
			return AbstractJavaEntity.this.associatedTableNamesIncludingInherited();
		}
		
		public org.eclipse.jpt.db.Table getDbTable(String tableName) {
			return AbstractJavaEntity.this.getDbTable(tableName);
		}

		public String getDefaultTableName() {
			return AbstractJavaEntity.this.getPrimaryTableName();
		}
		
		public String getPossiblePrefix() {
			return null;
		}
		
		public String getWritePrefix() {
			return null;
		}
		
		public boolean isRelevant(String overrideName) {
			//no prefix, so always true
			return true;
		}
		
		public TextRange getValidationTextRange(CompilationUnit astRoot) {
			return AbstractJavaEntity.this.getValidationTextRange(astRoot);
		}
		
		public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {
			if (override.isVirtual()) {
				return this.buildVirtualColumnUnresolvedNameMessage(override.getName(), column, textRange);

				textRange
			);
		}
		
		public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {
			if (override.isVirtual()) {
				return this.buildVirtualColumnTableNotValidMessage(override.getName(), column, textRange);

				textRange
			);
		}
		
		protected IMessage buildVirtualColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

Lines 46-59 Link Here

(-)src/org/eclipse/jpt/core/internal/context/java/AbstractJavaBaseEmbeddedMapping.java (-16 / +40 lines)
46	implements JavaBaseEmbeddedMapping	46	implements JavaBaseEmbeddedMapping
47	{	47	{
48	protected final JavaAttributeOverrideContainer attributeOverrideContainer;	48	protected final JavaAttributeOverrideContainer attributeOverrideContainer;
49		49
50	private Embeddable targetEmbeddable;	50	private Embeddable targetEmbeddable;
51		51
		52
52	protected AbstractJavaBaseEmbeddedMapping(JavaPersistentAttribute parent) {	53	protected AbstractJavaBaseEmbeddedMapping(JavaPersistentAttribute parent) {
53	super(parent);	54	super(parent);
54	this.attributeOverrideContainer = this.getJpaFactory().buildJavaAttributeOverrideContainer(this, new AttributeOverrideContainerOwner());	55	this.attributeOverrideContainer =
		56	this.getJpaFactory().buildJavaAttributeOverrideContainer(
		57	this,
		58	buildAttributeOverrideContainerOwner());
55	}	59	}
56		60
		61
		62	protected JavaAttributeOverrideContainer.Owner buildAttributeOverrideContainerOwner() {
		63	return new AttributeOverrideContainerOwner();
		64	}
		65
57	public JavaAttributeOverrideContainer getAttributeOverrideContainer() {	66	public JavaAttributeOverrideContainer getAttributeOverrideContainer() {
58	return this.attributeOverrideContainer;	67	return this.attributeOverrideContainer;
59	}	68	}
Lines 62-67 Link Here
62	return this.targetEmbeddable;	71	return this.targetEmbeddable;
63	}	72	}
64		73
		74
65	//**************** JavaAttributeMapping implementation *****************	75	//**************** JavaAttributeMapping implementation *****************
66		76
67	@Override	77	@Override
Lines 211-223 Link Here
211		221
212	//******** AttributeOverrideContainer.Owner implementation *******	222	//******** AttributeOverrideContainer.Owner implementation *******
213		223
214	class AttributeOverrideContainerOwner implements JavaAttributeOverrideContainer.Owner {	224	protected class AttributeOverrideContainerOwner
		225	implements JavaAttributeOverrideContainer.Owner
		226	{
		227	public TypeMapping getTypeMapping() {
		228	return AbstractJavaBaseEmbeddedMapping.this.getTypeMapping();
		229	}
		230
215	public TypeMapping getOverridableTypeMapping() {	231	public TypeMapping getOverridableTypeMapping() {
216	return AbstractJavaBaseEmbeddedMapping.this.getOverridableTypeMapping();	232	return AbstractJavaBaseEmbeddedMapping.this.getOverridableTypeMapping();
217	}	233	}
218		234
219	public TypeMapping getTypeMapping() {	235	public Iterator<String> allOverridableNames() {
220	return AbstractJavaBaseEmbeddedMapping.this.getTypeMapping();	236	TypeMapping typeMapping = getOverridableTypeMapping();
		237	return (typeMapping == null) ?
		238	EmptyIterator.<String>instance()
		239	: allOverridableAttributeNames_(typeMapping);
		240	}
		241
		242	/* assumes the type mapping is not null */
		243	protected Iterator<String> allOverridableAttributeNames_(TypeMapping typeMapping) {
		244	return typeMapping.allOverridableAttributeNames();
221	}	245	}
222		246
223	public Column resolveOverriddenColumn(String attributeOverrideName) {	247	public Column resolveOverriddenColumn(String attributeOverrideName) {
Lines 239-262 Link Here
239	public String getDefaultTableName() {	263	public String getDefaultTableName() {
240	return getTypeMapping().getPrimaryTableName();	264	return getTypeMapping().getPrimaryTableName();
241	}	265	}
242		266
243	public String getPossiblePrefix() {	267	public String getPossiblePrefix() {
244	return null;	268	return null;
245	}	269	}
246		270
247	public String getWritePrefix() {	271	public String getWritePrefix() {
248	return null;	272	return null;
249	}	273	}
250		274
251	public boolean isRelevant(String overrideName) {	275	public boolean isRelevant(String overrideName) {
252	//no prefix, so always true	276	//no prefix, so always true
253	return true;	277	return true;
254	}	278	}
255		279
256	public TextRange getValidationTextRange(CompilationUnit astRoot) {	280	public TextRange getValidationTextRange(CompilationUnit astRoot) {
257	return AbstractJavaBaseEmbeddedMapping.this.getValidationTextRange(astRoot);	281	return AbstractJavaBaseEmbeddedMapping.this.getValidationTextRange(astRoot);
258	}	282	}
259		283
260	public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {	284	public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {
261	if (override.isVirtual()) {	285	if (override.isVirtual()) {
262	return this.buildVirtualColumnTableNotValidMessage(override.getName(), column, textRange);	286	return this.buildVirtualColumnTableNotValidMessage(override.getName(), column, textRange);
Lines 272-278 Link Here
272	textRange	296	textRange
273	);	297	);
274	}	298	}
275		299
276	protected IMessage buildVirtualColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {	300	protected IMessage buildVirtualColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
277	return DefaultJpaValidationMessages.buildMessage(	301	return DefaultJpaValidationMessages.buildMessage(
278	IMessage.HIGH_SEVERITY,	302	IMessage.HIGH_SEVERITY,
Lines 286-292 Link Here
286	textRange	310	textRange
287	);	311	);
288	}	312	}
289		313
290	public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {	314	public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {
291	if (override.isVirtual()) {	315	if (override.isVirtual()) {
292	return this.buildVirtualColumnUnresolvedNameMessage(override.getName(), column, textRange);	316	return this.buildVirtualColumnUnresolvedNameMessage(override.getName(), column, textRange);
Lines 299-305 Link Here
299	textRange	323	textRange
300	);	324	);
301	}	325	}
302		326
303	protected IMessage buildVirtualColumnUnresolvedNameMessage(String overrideName, NamedColumn column, TextRange textRange) {	327	protected IMessage buildVirtualColumnUnresolvedNameMessage(String overrideName, NamedColumn column, TextRange textRange) {
304	return DefaultJpaValidationMessages.buildMessage(	328	return DefaultJpaValidationMessages.buildMessage(
305	IMessage.HIGH_SEVERITY,	329	IMessage.HIGH_SEVERITY,
Lines 310-313 Link Here
310	);	334	);
311	}	335	}
312	}	336	}
313	}	337	}

Lines 11-17 Link Here

(-)src/org/eclipse/jpt/core/internal/context/java/AbstractJavaNamedColumn.java (-2 / +2 lines)
11		11
12	import java.util.Iterator;	12	import java.util.Iterator;
13	import java.util.List;	13	import java.util.List;
14
15	import org.eclipse.jdt.core.dom.CompilationUnit;	14	import org.eclipse.jdt.core.dom.CompilationUnit;
16	import org.eclipse.jpt.core.context.NamedColumn;	15	import org.eclipse.jpt.core.context.NamedColumn;
17	import org.eclipse.jpt.core.context.java.JavaJpaContextNode;	16	import org.eclipse.jpt.core.context.java.JavaJpaContextNode;
Lines 28-34 Link Here
28	import org.eclipse.wst.validation.internal.provisional.core.IReporter;	27	import org.eclipse.wst.validation.internal.provisional.core.IReporter;
29		28
30		29
31	public abstract class AbstractJavaNamedColumn<T extends NamedColumnAnnotation> extends AbstractJavaJpaContextNode	30	public abstract class AbstractJavaNamedColumn<T extends NamedColumnAnnotation>
		31	extends AbstractJavaJpaContextNode
32	implements JavaNamedColumn	32	implements JavaNamedColumn
33	{	33	{
34		34





	// ********** override container owners **********

	abstract class OverrideContainerOwner
		implements JavaOverrideContainer.Owner
	{
		public TypeMapping getTypeMapping() {
			return GenericJavaElementCollectionMapping2_0.this.getTypeMapping();
		}

		public org.eclipse.jpt.db.Table getDbTable(String tableName) {
			return GenericJavaElementCollectionMapping2_0.this.getCollectionTable().getDbTable();
		}
		
		public java.util.Iterator<String> candidateTableNames() {
			return EmptyIterator.instance();
		}

			return GenericJavaElementCollectionMapping2_0.this.getValidationTextRange(astRoot);
		}
	}
	
	class ValueAssociationOverrideContainerOwner
		extends OverrideContainerOwner
		implements JavaAssociationOverrideContainer.Owner
	{
		public TypeMapping getOverridableTypeMapping() {
			return GenericJavaElementCollectionMapping2_0.this.getResolvedTargetEmbeddable();
		}
		
		public Iterator<String> allOverridableNames() {
			TypeMapping typeMapping = getOverridableTypeMapping();
			return (typeMapping == null) ? 
					EmptyIterator.<String>instance()
					: typeMapping.allOverridableAssociationNames();
		}
		
		public RelationshipReference resolveRelationshipReference(String associationOverrideName) {
			return MappingTools.resolveRelationshipReference(getOverridableTypeMapping(), associationOverrideName);
		}	
		
		public String getPossiblePrefix() {
			return "value."; //$NON-NLS-1$
		}
		
		public String getWritePrefix() {
			return getPersistentAttribute().getJpaContainer().isMap() ? this.getPossiblePrefix() : null;
		}
		
		//return false if the override is prefixed with "key.", these will be part of the MapKeyAttributeOverrideContainer.
		//a prefix of "value." or no prefix at all is relevant. If the type is not a Map then return true since all attribute overrides
		//need to apply to the value.

			}
			return !overrideName.startsWith("key."); //$NON-NLS-1$
		}
		
		public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {
			if (override.isVirtual()) {
				return this.buildVirtualOverrideColumnTableNotValidMessage(override.getName(), column, textRange);

				textRange
			);
		}
		
		protected IMessage buildVirtualOverrideColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
			);
		}
		
		public IMessage buildColumnUnresolvedReferencedColumnNameMessage(AssociationOverride override, BaseJoinColumn column, TextRange textRange) {
			if (override.isVirtual()) {
				return this.buildVirtualColumnUnresolvedReferencedColumnNameMessage(override.getName(), column, textRange);

				textRange
			);
		}
		
		protected IMessage buildVirtualColumnUnresolvedReferencedColumnNameMessage(String overrideName, BaseJoinColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
			);
		}
		
		public IMessage buildUnspecifiedNameMultipleJoinColumnsMessage(AssociationOverride override, BaseJoinColumn column, TextRange textRange) {
			if (override.isVirtual()) {
				return this.buildVirtualUnspecifiedNameMultipleJoinColumnsMessage(override.getName(), column, textRange);

				textRange
			);
		}
		
		protected IMessage buildVirtualUnspecifiedNameMultipleJoinColumnsMessage(String overrideName, BaseJoinColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
			);
		}
		
		protected IMessage buildVirtualUnspecifiedReferencedColumnNameMultipleJoinColumnsMessage(String overrideName, BaseJoinColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

			return GenericJavaElementCollectionMapping2_0.this.getResolvedTargetEmbeddable();
		}
		
		public Iterator<String> allOverridableNames() {
			TypeMapping typeMapping = getOverridableTypeMapping();
			return (typeMapping == null) ? 
					EmptyIterator.<String>instance()
					: typeMapping.allOverridableAttributeNames();
		}
		
		public Column resolveOverriddenColumn(String attributeOverrideName) {
			return MappingTools.resolveOverridenColumn(getOverridableTypeMapping(), attributeOverrideName);
		}
		
		public String getPossiblePrefix() {
			return "value."; //$NON-NLS-1$
		}
		
		public String getWritePrefix() {
			return getPersistentAttribute().getJpaContainer().isMap() ? this.getPossiblePrefix() : null;
		}
		
		//return false if the override is prefixed with "key.", these will be part of the MapKeyAttributeOverrideContainer.
		//a prefix of "value." or no prefix at all is relevant. If the type is not a Map then return true since all attribute overrides
		//need to apply to the value.

			}
			return !overrideName.startsWith("key."); //$NON-NLS-1$
		}
		
		public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {
			if (override.isVirtual()) {
				return this.buildVirtualColumnUnresolvedNameMessage(override.getName(), column, textRange);

				textRange
			);
		}
		
		public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {
			if (override.isVirtual()) {
				return this.buildVirtualColumnTableNotValidMessage(override.getName(), column, textRange);

				textRange
			);
		}
		
		protected IMessage buildVirtualColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

		}
	}
	
	
	class MapKeyAttributeOverrideContainerOwner
		extends OverrideContainerOwner
		implements JavaAttributeOverrideContainer.Owner
	{
		public TypeMapping getOverridableTypeMapping() {
			return GenericJavaElementCollectionMapping2_0.this.getResolvedMapKeyEmbeddable();
		}
		
		public Iterator<String> allOverridableNames() {
			TypeMapping typeMapping = getOverridableTypeMapping();
			return (typeMapping == null) ? 
					EmptyIterator.<String>instance()
					: typeMapping.allOverridableAttributeNames();
		}
		
		public String getPossiblePrefix() {
			return "key."; //$NON-NLS-1$
		}
		
		public String getWritePrefix() {
			return this.getPossiblePrefix();
		}
		
		//the only relevant overrides are those that start with "key.", no prefix will be a value attribute override
		public boolean isRelevant(String overrideName) {
			if (getValueType() != Type.EMBEDDABLE_TYPE) {

			}
			return overrideName.startsWith("key."); //$NON-NLS-1$
		}
		
		public TypeMapping getOverridableTypeMapping() {
			return GenericJavaElementCollectionMapping2_0.this.getResolvedMapKeyEmbeddable();
		}
	
		public Column resolveOverriddenColumn(String attributeOverrideName) {
			return MappingTools.resolveOverridenColumn(getOverridableTypeMapping(), attributeOverrideName);
		}
		
		public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {
			if (override.isVirtual()) {
				return this.buildVirtualColumnUnresolvedNameMessage(override.getName(), column, textRange);

				textRange
			);
		}
		
		public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {
			if (override.isVirtual()) {
				return this.buildVirtualColumnTableNotValidMessage(override.getName(), column, textRange);

				textRange
			);
		}
		
		protected IMessage buildVirtualColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

Lines 14-21 Link Here

(-)src/org/eclipse/jpt/core/context/orm/OrmAttributeOverride.java (-3 / +1 lines)
14	import org.eclipse.jpt.core.resource.orm.XmlAttributeOverride;	14	import org.eclipse.jpt.core.resource.orm.XmlAttributeOverride;
15		15
16	/**	16	/**
17	*
18	*
19	* Provisional API: This interface is part of an interim API that is still	17	* Provisional API: This interface is part of an interim API that is still
20	* under development and expected to change significantly before reaching	18	* under development and expected to change significantly before reaching
21	* stability. It is available at this early stage to solicit feedback from	19	* stability. It is available at this early stage to solicit feedback from
Lines 37-40 Link Here
37	* resource model object. see {@link org.eclipse.jpt.core.JpaProject#update()}	35	* resource model object. see {@link org.eclipse.jpt.core.JpaProject#update()}
38	*/	36	*/
39	void update(XmlAttributeOverride attributeOverride);	37	void update(XmlAttributeOverride attributeOverride);
40	}	38	}

Lines 9-32 Link Here

(-)src/org/eclipse/jpt/core/internal/jpa1/context/orm/GenericOrmEmbeddedIdMapping.java (-4 / +148 lines)
9	******************************************************************************/	9	******************************************************************************/
10	package org.eclipse.jpt.core.internal.jpa1.context.orm;	10	package org.eclipse.jpt.core.internal.jpa1.context.orm;
11		11
		12	import java.util.Collection;
		13	import java.util.Iterator;
		14	import java.util.List;
12	import org.eclipse.jpt.core.MappingKeys;	15	import org.eclipse.jpt.core.MappingKeys;
		16	import org.eclipse.jpt.core.context.AttributeMapping;
		17	import org.eclipse.jpt.core.context.TypeMapping;
13	import org.eclipse.jpt.core.context.orm.OrmAttributeMapping;	18	import org.eclipse.jpt.core.context.orm.OrmAttributeMapping;
		19	import org.eclipse.jpt.core.context.orm.OrmAttributeOverrideContainer;
14	import org.eclipse.jpt.core.context.orm.OrmEmbeddedIdMapping;	20	import org.eclipse.jpt.core.context.orm.OrmEmbeddedIdMapping;
15	import org.eclipse.jpt.core.context.orm.OrmPersistentAttribute;	21	import org.eclipse.jpt.core.context.orm.OrmPersistentAttribute;
16	import org.eclipse.jpt.core.internal.context.orm.AbstractOrmBaseEmbeddedMapping;	22	import org.eclipse.jpt.core.internal.context.orm.AbstractOrmBaseEmbeddedMapping;
		23	import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages;
		24	import org.eclipse.jpt.core.internal.validation.JpaValidationMessages;
		25	import org.eclipse.jpt.core.jpa2.context.EmbeddedIdMapping2_0;
		26	import org.eclipse.jpt.core.jpa2.context.SingleRelationshipMapping2_0;
17	import org.eclipse.jpt.core.resource.orm.Attributes;	27	import org.eclipse.jpt.core.resource.orm.Attributes;
18	import org.eclipse.jpt.core.resource.orm.XmlEmbeddedId;	28	import org.eclipse.jpt.core.resource.orm.XmlEmbeddedId;
		29	import org.eclipse.jpt.utility.internal.CollectionTools;
		30	import org.eclipse.jpt.utility.internal.iterables.CompositeIterable;
		31	import org.eclipse.jpt.utility.internal.iterables.FilteringIterable;
		32	import org.eclipse.jpt.utility.internal.iterables.SubIterableWrapper;
		33	import org.eclipse.jpt.utility.internal.iterators.EmptyIterator;
		34	import org.eclipse.jpt.utility.internal.iterators.FilteringIterator;
		35	import org.eclipse.jpt.utility.internal.iterators.TransformationIterator;
		36	import org.eclipse.wst.validation.internal.provisional.core.IMessage;
		37	import org.eclipse.wst.validation.internal.provisional.core.IReporter;
19		38
20		39
21	public class GenericOrmEmbeddedIdMapping	40	public class GenericOrmEmbeddedIdMapping
22	extends AbstractOrmBaseEmbeddedMapping<XmlEmbeddedId>	41	extends AbstractOrmBaseEmbeddedMapping<XmlEmbeddedId>
23	implements OrmEmbeddedIdMapping	42	implements EmbeddedIdMapping2_0, OrmEmbeddedIdMapping
24	{	43	{
25		44	/* 2.0 feature - a relationship may map this embedded id */
		45	protected boolean mappedByRelationship;
		46
		47
26	public GenericOrmEmbeddedIdMapping(OrmPersistentAttribute parent, XmlEmbeddedId resourceMapping) {	48	public GenericOrmEmbeddedIdMapping(OrmPersistentAttribute parent, XmlEmbeddedId resourceMapping) {
27	super(parent, resourceMapping);	49	super(parent, resourceMapping);
		50	this.mappedByRelationship = calculateMappedByRelationship();
28	}	51	}
29		52
		53
30	public void initializeOn(OrmAttributeMapping newMapping) {	54	public void initializeOn(OrmAttributeMapping newMapping) {
31	newMapping.initializeFromOrmEmbeddedIdMapping(this);	55	newMapping.initializeFromOrmEmbeddedIdMapping(this);
32	}	56	}
Lines 35-46 Link Here
35	return 10;	59	return 10;
36	}	60	}
37		61
		62
38	//************* AttributeMapping implementation *******************	63	//************* AttributeMapping implementation *******************
39		64
40	public String getKey() {	65	public String getKey() {
41	return MappingKeys.EMBEDDED_ID_ATTRIBUTE_MAPPING_KEY;	66	return MappingKeys.EMBEDDED_ID_ATTRIBUTE_MAPPING_KEY;
42	}	67	}
43		68
44	public void addToResourceModel(Attributes resourceAttributes) {	69	public void addToResourceModel(Attributes resourceAttributes) {
45	resourceAttributes.getEmbeddedIds().add(this.resourceAttributeMapping);	70	resourceAttributes.getEmbeddedIds().add(this.resourceAttributeMapping);
46	}	71	}
Lines 48-51 Link Here
48	public void removeFromResourceModel(Attributes resourceAttributes) {	73	public void removeFromResourceModel(Attributes resourceAttributes) {
49	resourceAttributes.getEmbeddedIds().remove(this.resourceAttributeMapping);	74	resourceAttributes.getEmbeddedIds().remove(this.resourceAttributeMapping);
50	}	75	}
		76
		77
		78	// ************** EmbeddedId2_0 impl **********************************
		79
		80	public boolean isMappedByRelationship() {
		81	return this.mappedByRelationship;
		82	}
		83
		84	protected void setMappedByRelationship(boolean newValue) {
		85	boolean oldValue = this.mappedByRelationship;
		86	this.mappedByRelationship = newValue;
		87	firePropertyChanged(MAPPED_BY_RELATIONSHIP_PROPERTY, oldValue, newValue);
		88	}
		89
		90	protected boolean calculateMappedByRelationship() {
		91	for (SingleRelationshipMapping2_0 each : getMapsIdRelationships()) {
		92	if (getName().equals(each.getDerivedIdentity().getMapsIdDerivedIdentityStrategy().getValue())) {
		93	return true;
		94	}
		95	}
		96	return false;
		97	}
		98
		99	protected Iterable<SingleRelationshipMapping2_0> getMapsIdRelationships() {
		100	return new FilteringIterable<SingleRelationshipMapping2_0>(
		101	new SubIterableWrapper<AttributeMapping, SingleRelationshipMapping2_0>(
		102	new CompositeIterable<AttributeMapping>(
		103	getTypeMapping().getAllAttributeMappings(MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY),
		104	getTypeMapping().getAllAttributeMappings(MappingKeys.MANY_TO_ONE_ATTRIBUTE_MAPPING_KEY)))) {
		105	@Override
		106	protected boolean accept(SingleRelationshipMapping2_0 o) {
		107	return o.getDerivedIdentity().usesMapsIdDerivedIdentityStrategy();
		108	}
		109	};
		110	}
		111
		112
		113	// ************** overrides *******************************************
		114
		115	@Override
		116	protected Iterator<String> embeddableOverrideableAttributeMappingNames() {
		117	return (isMappedByRelationship()) ?
		118	EmptyIterator.<String>instance()
		119	: super.embeddableOverrideableAttributeMappingNames();
		120	}
		121
		122	@Override
		123	protected OrmAttributeOverrideContainer.Owner buildAttributeOverrideContainerOwner() {
		124	return new AttributeOverrideContainerOwner();
		125	}
		126
		127
		128	protected class AttributeOverrideContainerOwner
		129	extends AbstractOrmBaseEmbeddedMapping.AttributeOverrideContainerOwner
		130	{
		131	@Override
		132	public Iterator allOverridableNames() {
		133	return (GenericOrmEmbeddedIdMapping.this.isMappedByRelationship()) ?
		134	EmptyIterator.<String>instance()
		135	: super.allOverridableNames();
		136	}
		137
		138	@Override
		139	protected Iterator allOverridableAttributeNames_(TypeMapping typeMapping) {
140	final Collection mappedByRelationshipAttributes = CollectionTools.collection(
141	new TransformationIterator<SingleRelationshipMapping2_0, String>(getMapsIdRelationships()) {
142	@Override
143	protected String transform(SingleRelationshipMapping2_0 next) {
144	return next.getDerivedIdentity().getMapsIdDerivedIdentityStrategy().getValue();
145	}
146	});
147	return new FilteringIterator<String>(super.allOverridableAttributeNames_(typeMapping)) {
148	@Override
149	protected boolean accept(String o) {
150	if (mappedByRelationshipAttributes.isEmpty()) {
151	return true;
152	}
153	// overrideable names are (usually?) qualified with a container mapping,
154	// which may also be the one mapped by a relationship
155	String qualifier =
156	(o.indexOf('.') > 0) ?
157	o.substring(0, o.indexOf('.'))
158	: o;
159	return ! mappedByRelationshipAttributes.contains(qualifier);
160	}
161	};
162	}
163	}
164
165
166	// ************** resource -> context *********************************
167
168	@Override
169	public void update() {
170	super.update();
171	setMappedByRelationship(calculateMappedByRelationship());
172	}
173
174
175	// ************** validation ******************************************
176
177	@Override
178	public void validate(List<IMessage> messages, IReporter reporter) {
179	super.validate(messages, reporter);
180
181	// [JPA 2.0] if the embedded id is mapped by a relationship, then any specified
182	// attribute overrides are in error
183	// (in JPA 1.0, this will obviously never be reached)
184	if (isMappedByRelationship()
185	&& getAttributeOverrideContainer().specifiedAttributeOverridesSize() > 0) {
186	messages.add(
187	DefaultJpaValidationMessages.buildMessage(
188	IMessage.HIGH_SEVERITY,
189	JpaValidationMessages.EMBEDDED_ID_MAPPING_MAPPED_BY_RELATIONSHIP_AND_ATTRIBUTE_OVERRIDES_SPECIFIED,
190	new String[] {},
191	getAttributeOverrideContainer(),
192	getAttributeOverrideContainer().getValidationTextRange()));
193	}
194	}
51	}	195	}





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

import org.eclipse.emf.common.util.EList;
import org.eclipse.jpt.core.MappingKeys;
import org.eclipse.jpt.core.context.AssociationOverride;

	
	//********** OrmAssociationOverrideContainer.Owner implementation *********	
	
	class AssociationOverrideContainerOwner
		implements OrmAssociationOverrideContainer.Owner
	{
		public OrmTypeMapping getTypeMapping() {
			return GenericOrmEmbeddedMapping.this.getTypeMapping();
		}
		
		public TypeMapping getOverridableTypeMapping() {
			return GenericOrmEmbeddedMapping.this.getTargetEmbeddable();
		}
		
		public Iterator<String> allOverridableNames() {
			TypeMapping typeMapping = getOverridableTypeMapping();
			return (typeMapping == null) ? 
					EmptyIterator.<String>instance()
					: typeMapping.allOverridableAssociationNames();
		}
		
		public EList<XmlAssociationOverride> getResourceAssociationOverrides() {
			return GenericOrmEmbeddedMapping.this.resourceAttributeMapping.getAssociationOverrides();
		}
		
		public RelationshipReference resolveRelationshipReference(String associationOverrideName) {
			if (getPersistentAttribute().isVirtual() && !getTypeMapping().isMetadataComplete()) {
				JavaAssociationOverride javaAssociationOverride = getJavaAssociationOverrideNamed(associationOverrideName);

		public Iterator<String> candidateTableNames() {
			return getTypeMapping().associatedTableNamesIncludingInherited();
		}
		
		public org.eclipse.jpt.db.Table getDbTable(String tableName) {
			return getTypeMapping().getDbTable(tableName);
		}

		public String getDefaultTableName() {
			return getTypeMapping().getPrimaryTableName();
		}
		
		public TextRange getValidationTextRange() {
			return GenericOrmEmbeddedMapping.this.getValidationTextRange();
		}
		
		public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {
			if (isVirtual()) {
				return this.buildVirtualAttributeColumnTableNotValidMessage(override.getName(), column, textRange);

					textRange
				);
		}
		
		protected IMessage buildVirtualAttributeColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
			);
		}
		
		protected IMessage buildVirtualOverrideColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
			);
		}
		
		public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {
			if (isVirtual()) {
				return this.buildVirtualAttributeColumnUnresolvedNameMessage(override.getName(), column, textRange);

				textRange
			);
		}
		
		protected IMessage buildVirtualAttributeColumnUnresolvedNameMessage(String overrideName, NamedColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
				);
		}
		
		public IMessage buildColumnUnresolvedReferencedColumnNameMessage(AssociationOverride override, BaseJoinColumn column, TextRange textRange) {
			if (isVirtual()) {
				return this.buildVirtualAttributeColumnUnresolvedReferencedColumnNameMessage(override.getName(), column, textRange);

				textRange
			);
		}
		
		protected IMessage buildVirtualAttributeColumnUnresolvedReferencedColumnNameMessage(String overrideName, BaseJoinColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
			);
		}
		
		protected IMessage buildVirtualAttributeUnspecifiedNameMultipleJoinColumnsMessage(String overrideName, BaseJoinColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
			);
		}
		
		public IMessage buildUnspecifiedReferencedColumnNameMultipleJoinColumnsMessage(AssociationOverride override, BaseJoinColumn column, TextRange textRange) {
			if (isVirtual()) {
				return this.buildVirtualAttributeUnspecifiedReferencedColumnNameMultipleJoinColumnsMessage(override.getName(), column, textRange);

				textRange
			);
		}
		
		protected IMessage buildVirtualAttributeUnspecifiedReferencedColumnNameMultipleJoinColumnsMessage(String overrideName, BaseJoinColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

Lines 11-16 Link Here

(-)src/org/eclipse/jpt/core/internal/jpa1/context/orm/GenericOrmAttributeOverride.java (-30 / +125 lines)
11		11
12	import java.util.Iterator;	12	import java.util.Iterator;
13	import java.util.List;	13	import java.util.List;
		14	import org.eclipse.jpt.core.MappingKeys;
		15	import org.eclipse.jpt.core.context.AttributeMapping;
14	import org.eclipse.jpt.core.context.AttributeOverride;	16	import org.eclipse.jpt.core.context.AttributeOverride;
15	import org.eclipse.jpt.core.context.BaseColumn;	17	import org.eclipse.jpt.core.context.BaseColumn;
16	import org.eclipse.jpt.core.context.Column;	18	import org.eclipse.jpt.core.context.Column;
Lines 19-80 Link Here
19	import org.eclipse.jpt.core.context.orm.OrmAttributeOverride;	21	import org.eclipse.jpt.core.context.orm.OrmAttributeOverride;
20	import org.eclipse.jpt.core.context.orm.OrmAttributeOverrideContainer;	22	import org.eclipse.jpt.core.context.orm.OrmAttributeOverrideContainer;
21	import org.eclipse.jpt.core.context.orm.OrmColumn;	23	import org.eclipse.jpt.core.context.orm.OrmColumn;
		24	import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages;
		25	import org.eclipse.jpt.core.internal.validation.JpaValidationMessages;
		26	import org.eclipse.jpt.core.jpa2.context.AttributeOverride2_0;
		27	import org.eclipse.jpt.core.jpa2.context.SingleRelationshipMapping2_0;
22	import org.eclipse.jpt.core.resource.orm.OrmFactory;	28	import org.eclipse.jpt.core.resource.orm.OrmFactory;
23	import org.eclipse.jpt.core.resource.orm.XmlAttributeOverride;	29	import org.eclipse.jpt.core.resource.orm.XmlAttributeOverride;
24	import org.eclipse.jpt.core.resource.orm.XmlColumn;	30	import org.eclipse.jpt.core.resource.orm.XmlColumn;
25	import org.eclipse.jpt.core.utility.TextRange;	31	import org.eclipse.jpt.core.utility.TextRange;
26	import org.eclipse.jpt.db.Table;	32	import org.eclipse.jpt.db.Table;
		33	import org.eclipse.jpt.utility.internal.iterables.CompositeIterable;
		34	import org.eclipse.jpt.utility.internal.iterables.FilteringIterable;
		35	import org.eclipse.jpt.utility.internal.iterables.SubIterableWrapper;
27	import org.eclipse.wst.validation.internal.provisional.core.IMessage;	36	import org.eclipse.wst.validation.internal.provisional.core.IMessage;
28	import org.eclipse.wst.validation.internal.provisional.core.IReporter;	37	import org.eclipse.wst.validation.internal.provisional.core.IReporter;
29		38
30		39	public class GenericOrmAttributeOverride
31	public class GenericOrmAttributeOverride extends AbstractOrmOverride	40	extends AbstractOrmOverride
32	implements OrmAttributeOverride, OrmColumn.Owner	41	implements AttributeOverride2_0, OrmAttributeOverride, OrmColumn.Owner
33	{	42	{
34
35	protected final OrmColumn column;	43	protected final OrmColumn column;
36		44
37	public GenericOrmAttributeOverride(OrmAttributeOverrideContainer parent, AttributeOverride.Owner owner, XmlAttributeOverride resourceAttributeOverride) {	45	/* 2.0 feature - a relationship may map this attribute override */
		46	protected boolean mappedByRelationship;
		47
		48
		49	public GenericOrmAttributeOverride(
		50	OrmAttributeOverrideContainer parent,
		51	AttributeOverride.Owner owner,
		52	XmlAttributeOverride resourceAttributeOverride) {
		53
38	super(parent, owner, resourceAttributeOverride);	54	super(parent, owner, resourceAttributeOverride);
39	this.column = getXmlContextNodeFactory().buildOrmColumn(this, this);	55	this.column = getXmlContextNodeFactory().buildOrmColumn(this, this);
40	this.column.initialize(resourceAttributeOverride.getColumn());	56	this.column.initialize(resourceAttributeOverride.getColumn());
		57
		58	this.mappedByRelationship = //calculateMappedByRelationship();
		59	// TODO - move this real calculation to a (currently nonexistent) initialize method
		60	false;
41	}	61	}
42		62
		63
43	public OrmAttributeOverride setVirtual(boolean virtual) {	64	public OrmAttributeOverride setVirtual(boolean virtual) {
44	return (OrmAttributeOverride) getOwner().setVirtual(virtual, this);	65	return (OrmAttributeOverride) getOwner().setVirtual(virtual, this);
45	}	66	}
46		67
47	@Override	68	@Override
48	public Owner getOwner() {	69	public Owner getOwner() {
49	return (Owner) super.getOwner();	70	return (Owner) super.getOwner();
50	}	71	}
51		72
52	@Override	73	@Override
53	protected XmlAttributeOverride getResourceOverride() {	74	protected XmlAttributeOverride getResourceOverride() {
54	return (XmlAttributeOverride) super.getResourceOverride();	75	return (XmlAttributeOverride) super.getResourceOverride();
55	}	76	}
56
57	public void update(XmlAttributeOverride xmlAttributeOverride) {
58	super.update(xmlAttributeOverride);
59	this.column.update(xmlAttributeOverride.getColumn());
60	}
61		77
62		78
63	// ******************* column **************	79	// ******************* column **************
64		80
65	public OrmColumn getColumn() {	81	public OrmColumn getColumn() {
66	return this.column;	82	return this.column;
67	}	83	}
68		84
69	//*********** NamedColumn.Owner implementation ************	85	//*********** NamedColumn.Owner implementation ************
		86
70	public TypeMapping getTypeMapping() {	87	public TypeMapping getTypeMapping() {
71	return getOwner().getTypeMapping();	88	return getOwner().getTypeMapping();
72	}	89	}
73		90
74	public Table getDbTable(String tableName) {	91	public Table getDbTable(String tableName) {
75	return this.getOwner().getDbTable(tableName);	92	return this.getOwner().getDbTable(tableName);
76	}	93	}
77		94
78	public String getDefaultColumnName() {	95	public String getDefaultColumnName() {
79	Column column = resolveOverriddenColumn();	96	Column column = resolveOverriddenColumn();
80	if (column == null) {	97	if (column == null) {
Lines 83-88 Link Here
83	return column.getName();	100	return column.getName();
84	}	101	}
85		102
		103
86	//*********** BaseColumn.Owner implementation ************	104	//*********** BaseColumn.Owner implementation ************
87		105
88	public String getDefaultTableName() {	106	public String getDefaultTableName() {
Lines 100-125 Link Here
100	protected Column resolveOverriddenColumn() {	118	protected Column resolveOverriddenColumn() {
101	return getOwner().resolveOverriddenColumn(getName());	119	return getOwner().resolveOverriddenColumn(getName());
102	}	120	}
103		121
104	public boolean tableNameIsInvalid(String tableName) {	122	public boolean tableNameIsInvalid(String tableName) {
105	return getOwner().tableNameIsInvalid(tableName);	123	return getOwner().tableNameIsInvalid(tableName);
106	}	124	}
107		125
108	public Iterator<String> candidateTableNames() {	126	public Iterator<String> candidateTableNames() {
109	return getOwner().candidateTableNames();	127	return getOwner().candidateTableNames();
110	}	128	}
111		129
112	public boolean isVirtual() {	130	public boolean isVirtual() {
113	return getOwner().isVirtual(this);	131	return getOwner().isVirtual(this);
114	}	132	}
115		133
116		134
117	//*************** OrmColumn.Owner implementation **************	135	//*************** OrmColumn.Owner implementation **************
118		136
119	public XmlColumn getResourceColumn() {	137	public XmlColumn getResourceColumn() {
120	return this.getResourceOverride().getColumn();	138	return this.getResourceOverride().getColumn();
121	}	139	}
122		140
		141	protected boolean isColumnSpecified() {
		142	return getResourceColumn() != null;
		143	}
		144
123	public void addResourceColumn() {	145	public void addResourceColumn() {
124	this.getResourceOverride().setColumn(OrmFactory.eINSTANCE.createXmlColumn());	146	this.getResourceOverride().setColumn(OrmFactory.eINSTANCE.createXmlColumn());
125	}	147	}
Lines 127-146 Link Here
127	public void removeResourceColumn() {	149	public void removeResourceColumn() {
128	this.getResourceOverride().setColumn(null);	150	this.getResourceOverride().setColumn(null);
129	}	151	}
130		152
131		153
		154	// ************** AttributeOverride2_0 impl ***************************
		155
		156	public boolean isMappedByRelationship() {
		157	return this.mappedByRelationship;
		158	}
		159
		160	protected void setMappedByRelationship(boolean newValue) {
		161	boolean oldValue = this.mappedByRelationship;
		162	this.mappedByRelationship = newValue;
		163	firePropertyChanged(MAPPED_BY_RELATIONSHIP_PROPERTY, oldValue, newValue);
		164	}
		165
		166	protected boolean calculateMappedByRelationship() {
		167	for (SingleRelationshipMapping2_0 each : getMapsIdRelationships()) {
		168	if (getName() == null) {
		169	return false;
		170	}
		171
		172	// overrideable names are (usually?) qualified with a container mapping,
		173	// which may also be the one mapped by a relationship
		174	String qualifier =
		175	(getName().indexOf('.') > 0) ?
		176	getName().substring(0, getName().indexOf('.'))
		177	: getName();
		178	return qualifier.equals(each.getDerivedIdentity().getMapsIdDerivedIdentityStrategy().getValue());
		179	}
		180	return false;
		181	}
		182
		183	protected Iterable<SingleRelationshipMapping2_0> getMapsIdRelationships() {
		184	return new FilteringIterable<SingleRelationshipMapping2_0>(
		185	new SubIterableWrapper<AttributeMapping, SingleRelationshipMapping2_0>(
		186	new CompositeIterable<AttributeMapping>(
		187	getTypeMapping().getAllAttributeMappings(MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY),
		188	getTypeMapping().getAllAttributeMappings(MappingKeys.MANY_TO_ONE_ATTRIBUTE_MAPPING_KEY)))) {
		189	@Override
		190	protected boolean accept(SingleRelationshipMapping2_0 o) {
		191	return o.getDerivedIdentity().usesMapsIdDerivedIdentityStrategy();
		192	}
		193	};
		194	}
		195
		196
		197	// ************** resource -> context *********************************
		198
		199	public void update(XmlAttributeOverride xmlAttributeOverride) {
		200	super.update(xmlAttributeOverride);
		201	this.column.update(xmlAttributeOverride.getColumn());
		202	setMappedByRelationship(calculateMappedByRelationship());
		203	}
		204
		205
132	//**************** validation ******************	206	//**************** validation ******************
133		207
134	@Override	208	@Override
135	public void validate(List<IMessage> messages, IReporter reporter) {	209	public void validate(List<IMessage> messages, IReporter reporter) {
136	super.validate(messages, reporter);	210	super.validate(messages, reporter);
137	getColumn().validate(messages, reporter);	211
		212	// [JPA 2.0] if the column is specified, or if the override is not mapped by a relationship,
		213	// then the column is validated.
		214	// (In JPA 1.0, the column will always be validated, since the override is never mapped by a
		215	// relationship)
		216	if (isColumnSpecified() \|\| ! isMappedByRelationship()) {
		217	getColumn().validate(messages, reporter);
		218	}
		219
		220	// [JPA 2.0] if the override is mapped by a relationship, then that actually is in itself
		221	// a validation error
		222	// (We prevent implied overrides that are mapped by a relationship ... hopefully)
		223	// (In JPA 1.0, this will never occur)
		224	if (isMappedByRelationship()) {
		225	messages.add(
		226	DefaultJpaValidationMessages.buildMessage(
		227	IMessage.HIGH_SEVERITY,
		228	JpaValidationMessages.ATTRIBUTE_OVERRIDE_MAPPED_BY_RELATIONSHIP_AND_SPECIFIED,
		229	new String[] {},
		230	this,
		231	getValidationTextRange()));
		232	}
138	}	233	}
139		234
140	public IMessage buildUnresolvedNameMessage(NamedColumn column, TextRange textRange) {	235	public IMessage buildUnresolvedNameMessage(NamedColumn column, TextRange textRange) {
141	return getOwner().buildColumnUnresolvedNameMessage(this, column, textRange);	236	return getOwner().buildColumnUnresolvedNameMessage(this, column, textRange);
142	}	237	}
143		238
144	public IMessage buildTableNotValidMessage(BaseColumn column, TextRange textRange) {	239	public IMessage buildTableNotValidMessage(BaseColumn column, TextRange textRange) {
145	return getOwner().buildColumnTableNotValidMessage(this, column, textRange);	240	return getOwner().buildColumnTableNotValidMessage(this, column, textRange);
146	}	241	}




import org.eclipse.jpt.utility.internal.iterators.CloneIterator;
import org.eclipse.jpt.utility.internal.iterators.CloneListIterator;
import org.eclipse.jpt.utility.internal.iterators.CompositeListIterator;
import org.eclipse.jpt.utility.internal.iterators.EmptyIterator;
import org.eclipse.wst.validation.internal.provisional.core.IMessage;
import org.eclipse.wst.validation.internal.provisional.core.IReporter;

public class GenericOrmAttributeOverrideContainer
	extends AbstractOrmXmlContextNode
	implements OrmAttributeOverrideContainer
{
	
	protected final List<OrmAttributeOverride> specifiedAttributeOverrides;
	
	protected final List<OrmAttributeOverride> virtualAttributeOverrides;
	
	protected final Owner owner;
	
	
	public GenericOrmAttributeOverrideContainer(XmlContextNode parent, Owner owner) {
		super(parent);
		this.owner = owner;

		this.initializeSpecifiedAttributeOverrides();
		this.initializeVirtualAttributeOverrides();
	}
	
	
	public void initializeFromAttributeOverrideContainer(OrmAttributeOverrideContainer oldContainer) {
		int index = 0;
		for (OrmAttributeOverride attributeOverride : CollectionTools.iterable(oldContainer.specifiedAttributeOverrides())) {

	protected OrmAttributeOverride setAttributeOverrideSpecified(OrmAttributeOverride oldAttributeOverride) {
		int index = specifiedAttributeOverridesSize();
		XmlAttributeOverride xmlAttributeOverride = OrmFactory.eINSTANCE.createXmlAttributeOverride();
		OrmAttributeOverride newAttributeOverride = buildAttributeOverride(xmlAttributeOverride);
		this.specifiedAttributeOverrides.add(index, newAttributeOverride);
		
		this.getResourceAttributeOverrides().add(xmlAttributeOverride);

	}

	protected Iterator<String> allOverridableAttributeNames() {
		return getOwner().allOverridableNames();
		if (overridableTypeMapping != null) {
			return overridableTypeMapping.allOverridableAttributeNames();
		}
		return EmptyIterator.instance();
	}

	protected void initializeVirtualAttributeOverrides() {

	@Override
	public void validate(List<IMessage> messages, IReporter reporter) {
		super.validate(messages, reporter);
		
		for (Iterator<OrmAttributeOverride> stream = this.attributeOverrides(); stream.hasNext(); ) {
			stream.next().validate(messages, reporter);
		}
	}

	public TextRange getValidationTextRange() {
		if (specifiedAttributeOverridesSize() > 0) {
			return this.specifiedAttributeOverrides.get(0).getValidationTextRange();
		}
		return getOwner().getValidationTextRange();
	}
	




import org.eclipse.jpt.utility.internal.iterators.CloneIterator;
import org.eclipse.jpt.utility.internal.iterators.CloneListIterator;
import org.eclipse.jpt.utility.internal.iterators.CompositeListIterator;
import org.eclipse.jpt.utility.internal.iterators.EmptyIterator;
import org.eclipse.wst.validation.internal.provisional.core.IMessage;
import org.eclipse.wst.validation.internal.provisional.core.IReporter;


		return getOverrideNamed(name, overrides) != null;
	}
	

	protected Iterator<String> allOverridableAssociationNames() {
		return getOwner().allOverridableNames();
		if (overridableTypeMapping != null) {
			return overridableTypeMapping.allOverridableAssociationNames();
		}
		return EmptyIterator.instance();
	}
	
	protected void initializeVirtualAssociationOverrides() {

Lines 50-56 Link Here

(-)src/org/eclipse/jpt/core/internal/jpa1/context/orm/AbstractOrmOverride.java (+2 lines)
50	this.setName_(this.getResourceName());	50	this.setName_(this.getResourceName());
51	}	51	}
52		52
		53
53	// ******************* name **************	54	// ******************* name **************
		55
54	public String getName() {	56	public String getName() {
55	return this.name;	57	return this.name;
56	}	58	}

Lines 30-61 Link Here

(-)src/org/eclipse/jpt/core/context/OverrideContainer.java (-8 / +20 lines)
30	interface Owner	30	interface Owner
31	{	31	{
32	/**	32	/**
33	* Return the type mapping of the owning persistent type.	33	* Return the mapping of the persistent type where the container is defined.
		34	* (For example, on an entity, this would be the entity. On an embedded, this would
		35	* be the type mapping where the embedded is defined.)
34	*/	36	*/
35	TypeMapping getTypeMapping();	37	TypeMapping getTypeMapping();
36		38
37	/**	39	/**
38	* Return the overridable persistent type, not the owning persistent type.	40	* Return the type mapping that contains the attributes/associations to be overridden.
39	* This will be the persistent type of the mapped superclass or embeddable.	41	* (Though the type mapping may not directly own them. i.e. they may be on a supertype
		42	* mapping.)
		43	* (For example, on an entity, this would be the supertype mapping of that entity. On
		44	* an embedded, this would be the target type mapping of the embedded.)
40	*/	45	*/
41	TypeMapping getOverridableTypeMapping();	46	TypeMapping getOverridableTypeMapping();
42		47
		48	/**
		49	* Return an iterator of all the names of the attributes/associations to be overridden.
		50	* This is usually just all of the overridable names of the overridable type mapping.
		51	* @see #getOverridableTypeMapping()
		52	*/
		53	Iterator<String> allOverridableNames();
		54
43	/**	55	/**
44	* Return the name of the table which the column belongs to by default	56	* Return the name of the table which the column belongs to by default
45	*/	57	*/
46	String getDefaultTableName();	58	String getDefaultTableName();
47		59
48	/**	60	/**
49	* return whether the given table cannot be explicitly specified	61	* return whether the given table cannot be explicitly specified
50	* in the column's 'table' element	62	* in the column's 'table' element
51	*/	63	*/
52	boolean tableNameIsInvalid(String tableName);	64	boolean tableNameIsInvalid(String tableName);
53		65
54	/**	66	/**
55	* Return the database table for the specified table name	67	* Return the database table for the specified table name
56	*/	68	*/
57	org.eclipse.jpt.db.Table getDbTable(String tableName);	69	org.eclipse.jpt.db.Table getDbTable(String tableName);
58		70
59	/**	71	/**
60	* Return a list of table names that are valid for the overrides column, or join columns	72	* Return a list of table names that are valid for the overrides column, or join columns
61	*/	73	*/




package org.eclipse.jpt.core.context;

/**
 * 
 * 
 * Provisional API: This interface is part of an interim API that is still
 * under development and expected to change significantly before reaching
 * stability. It is available at this early stage to solicit feedback from

 * @version 2.3
 * @since 2.0
 */
public interface AttributeOverride
	extends BaseOverride, Column.Owner
{
	Column getColumn();
	

		 */
		Column resolveOverriddenColumn(String attributeName);
	}
}

Lines 71-76 Link Here

(-)property_files/jpa_validation.properties (+3 lines)
71	MAPPING_MAPPED_BY_WITH_JOIN_TABLE=Cannot specify join table if this attribute is mapped by another attribute	71	MAPPING_MAPPED_BY_WITH_JOIN_TABLE=Cannot specify join table if this attribute is mapped by another attribute
72	MAPPING_MAPPED_BY_ON_BOTH_SIDES=Relationship must have an owner	72	MAPPING_MAPPED_BY_ON_BOTH_SIDES=Relationship must have an owner
73	ID_MAPPING_UNRESOLVED_GENERATOR_NAME=Unresolved generator name \"{0}\"	73	ID_MAPPING_UNRESOLVED_GENERATOR_NAME=Unresolved generator name \"{0}\"
		74	ID_MAPPING_MAPPED_BY_RELATIONSHIP_AND_COLUMN_SPECIFIED=IDs that are mapped by a relationship should not specify a column.
		75	EMBEDDED_ID_MAPPING_MAPPED_BY_RELATIONSHIP_AND_ATTRIBUTE_OVERRIDES_SPECIFIED=Embedded IDs that are mapped by a relationship should not specify any attribute overrides.
		76	ATTRIBUTE_OVERRIDE_MAPPED_BY_RELATIONSHIP_AND_SPECIFIED=Attributes (or subattributes of an attribute) that are mapped by a relationship should not be overridden.
74	TABLE_UNRESOLVED_CATALOG=Catalog \"{0}\" cannot be resolved for table \"{1}\"	77	TABLE_UNRESOLVED_CATALOG=Catalog \"{0}\" cannot be resolved for table \"{1}\"
75	TABLE_UNRESOLVED_SCHEMA=Schema \"{0}\" cannot be resolved for table \"{1}\"	78	TABLE_UNRESOLVED_SCHEMA=Schema \"{0}\" cannot be resolved for table \"{1}\"
76	TABLE_UNRESOLVED_NAME=Table \"{0}\" cannot be resolved	79	TABLE_UNRESOLVED_NAME=Table \"{0}\" cannot be resolved




		}
	}

	class AssociationOverrideContainerOwner
		extends OverrideContainerOwner 
		implements OrmAssociationOverrideContainer.Owner
	{
		public TypeMapping getOverridableTypeMapping() {
			return GenericOrmElementCollectionMapping2_0.this.getResolvedTargetEmbeddable();
		}
		
		public Iterator<String> allOverridableNames() {
			TypeMapping typeMapping = getOverridableTypeMapping();
			return (typeMapping == null) ? 
					EmptyIterator.<String>instance()
					: typeMapping.allOverridableAssociationNames();
		}
		
		public EList<XmlAssociationOverride> getResourceAssociationOverrides() {
			return GenericOrmElementCollectionMapping2_0.this.resourceAttributeMapping.getAssociationOverrides();
		}
		
		public RelationshipReference resolveRelationshipReference(String associationOverrideName) {
			if (getPersistentAttribute().isVirtual() && !getTypeMapping().isMetadataComplete()) {
				JavaAssociationOverride javaAssociationOverride = getJavaValueAssociationOverrideNamed(associationOverrideName);

			}
			return MappingTools.resolveRelationshipReference(getOverridableTypeMapping(), associationOverrideName);
		}
		
		public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {
			if (isVirtual()) {
				return this.buildVirtualAttributeColumnTableNotValidMessage(override.getName(), column, textRange);

					textRange
				);
		}
		
		protected IMessage buildVirtualAttributeColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
			);
		}
		
		protected IMessage buildVirtualOverrideColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
			);
		}
		
		public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {
			if (isVirtual()) {
				return this.buildVirtualAttributeColumnUnresolvedNameMessage(override.getName(), column, textRange);

				textRange
			);
		}
		
		protected IMessage buildVirtualAttributeColumnUnresolvedNameMessage(String overrideName, NamedColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
			);
		}
		
		protected IMessage buildVirtualOverrideColumnUnresolvedNameMessage(String overrideName, NamedColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
			);
		}
		
		public IMessage buildColumnUnresolvedReferencedColumnNameMessage(AssociationOverride override, BaseJoinColumn column, TextRange textRange) {
			if (isVirtual()) {
				return this.buildVirtualAttributeColumnUnresolvedReferencedColumnNameMessage(override.getName(), column, textRange);

				textRange
			);
		}
		
		protected IMessage buildVirtualAttributeColumnUnresolvedReferencedColumnNameMessage(String overrideName, BaseJoinColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
			);
		}
		
		protected IMessage buildVirtualOverrideColumnUnresolvedReferencedColumnNameMessage(String overrideName, BaseJoinColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
			);
		}
		
		public IMessage buildUnspecifiedNameMultipleJoinColumnsMessage(AssociationOverride override, BaseJoinColumn column, TextRange textRange) {
			if (isVirtual()) {
				return this.buildVirtualAttributeUnspecifiedNameMultipleJoinColumnsMessage(override.getName(), column, textRange);

				textRange
			);
		}
		
		protected IMessage buildVirtualAttributeUnspecifiedNameMultipleJoinColumnsMessage(String overrideName, BaseJoinColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
			);
		}
		
		protected IMessage buildVirtualOverrideUnspecifiedNameMultipleJoinColumnsMessage(String overrideName, BaseJoinColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
			);
		}
		
		public IMessage buildUnspecifiedReferencedColumnNameMultipleJoinColumnsMessage(AssociationOverride override, BaseJoinColumn column, TextRange textRange) {
			if (isVirtual()) {
				return this.buildVirtualAttributeUnspecifiedReferencedColumnNameMultipleJoinColumnsMessage(override.getName(), column, textRange);

				textRange
			);
		}
		
		protected IMessage buildVirtualAttributeUnspecifiedReferencedColumnNameMultipleJoinColumnsMessage(String overrideName, BaseJoinColumn column, TextRange textRange) {
				return DefaultJpaValidationMessages.buildMessage(
					IMessage.HIGH_SEVERITY,

					textRange
				);
		}
		
		protected IMessage buildVirtualOverrideUnspecifiedReferencedColumnNameMultipleJoinColumnsMessage(String overrideName, BaseJoinColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
			);
		}
		
		public TextRange getValidationTextRange() {
			return GenericOrmElementCollectionMapping2_0.this.getValidationTextRange();
		}
	}
	
	
	//********** OrmAttributeOverrideContainer.Owner implementation *********	

	class ValueAttributeOverrideContainerOwner
		extends OverrideContainerOwner
		implements OrmAttributeOverrideContainer.Owner
	{
		public TypeMapping getOverridableTypeMapping() {
			return GenericOrmElementCollectionMapping2_0.this.getResolvedTargetEmbeddable();
		}
		
		public Iterator<String> allOverridableNames() {
			TypeMapping typeMapping = getOverridableTypeMapping();
			return (typeMapping == null) ? 
					EmptyIterator.<String>instance()
					: typeMapping.allOverridableAttributeNames();
		}
		
		public EList<XmlAttributeOverride> getResourceAttributeOverrides() {
			return GenericOrmElementCollectionMapping2_0.this.resourceAttributeMapping.getAttributeOverrides();
		}
		
		public Column resolveOverriddenColumn(String attributeOverrideName) {
			if (getPersistentAttribute().isVirtual() && !getTypeMapping().isMetadataComplete()) {
				JavaAttributeOverride javaAttributeOverride = getJavaValueAttributeOverrideNamed(attributeOverrideName);

			}
			return MappingTools.resolveOverridenColumn(getOverridableTypeMapping(), attributeOverrideName);
		}
		
		public XmlColumn buildVirtualXmlColumn(Column overridableColumn, String attributeName, boolean isMetadataComplete) {
			return new VirtualXmlAttributeOverrideColumn(overridableColumn);
		}
		
		public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {
			if (isVirtual()) {
				return this.buildVirtualAttributeColumnUnresolvedNameMessage(override.getName(), column, textRange);

				textRange
			);
		}
		
		protected IMessage buildVirtualAttributeColumnUnresolvedNameMessage(String overrideName, NamedColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
			);
		}
		
		protected IMessage buildVirtualOverrideColumnUnresolvedNameMessage(String overrideName, NamedColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
			);
		}
		
		public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {
			if (isVirtual()) {
				return this.buildVirtualAttributeColumnTableNotValidMessage(override.getName(), column, textRange);

					textRange
				);
		}
		
		protected IMessage buildVirtualAttributeColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
			);
		}
		
		protected IMessage buildVirtualOverrideColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
			);
		}
		
		public TextRange getValidationTextRange() {
			return GenericOrmElementCollectionMapping2_0.this.getValidationTextRange();
		}
	}
	
	
	class MapKeyAttributeOverrideContainerOwner
		extends OverrideContainerOwner
		implements OrmAttributeOverrideContainer.Owner
	{
		public TypeMapping getOverridableTypeMapping() {
			return GenericOrmElementCollectionMapping2_0.this.getResolvedMapKeyEmbeddable();
		}
		
		public Iterator<String> allOverridableNames() {
			TypeMapping typeMapping = getOverridableTypeMapping();
			return (typeMapping == null) ? 
					EmptyIterator.<String>instance()
					: typeMapping.allOverridableAttributeNames();
		}
		
		public EList<XmlAttributeOverride> getResourceAttributeOverrides() {
			return GenericOrmElementCollectionMapping2_0.this.resourceAttributeMapping.getMapKeyAttributeOverrides();
		}
		
		public Column resolveOverriddenColumn(String attributeOverrideName) {
			if (getPersistentAttribute().isVirtual() && !getTypeMapping().isMetadataComplete()) {
				JavaAttributeOverride javaAttributeOverride = getJavaMapKeyAttributeOverrideNamed(attributeOverrideName);

			}
			return MappingTools.resolveOverridenColumn(getOverridableTypeMapping(), attributeOverrideName);
		}
		
		public XmlColumn buildVirtualXmlColumn(Column overridableColumn, String attributeName, boolean isMetadataComplete) {
			return new VirtualXmlAttributeOverrideColumn(overridableColumn);
		}
		
		public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {
			if (isVirtual()) {
				return this.buildVirtualAttributeColumnUnresolvedNameMessage(override.getName(), column, textRange);

				textRange
			);
		}
		
		protected IMessage buildVirtualAttributeColumnUnresolvedNameMessage(String overrideName, NamedColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
			);
		}
		
		protected IMessage buildVirtualOverrideColumnUnresolvedNameMessage(String overrideName, NamedColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
			);
		}
		
		public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {
			if (isVirtual()) {
				return this.buildVirtualAttributeColumnTableNotValidMessage(override.getName(), column, textRange);

					textRange
				);
		}
		
		protected IMessage buildVirtualAttributeColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
			);
		}
		
		protected IMessage buildVirtualOverrideColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
			return DefaultJpaValidationMessages.buildMessage(
				IMessage.HIGH_SEVERITY,

				textRange
			);
		}
		
		public TextRange getValidationTextRange() {
			return GenericOrmElementCollectionMapping2_0.this.getValidationTextRange();
		}

Lines 77-82 Link Here

(-)src/org/eclipse/jpt/core/internal/validation/JpaValidationMessages.java (+3 lines)
77	public static final String MAPPING_MAPPED_BY_WITH_JOIN_TABLE = "MAPPING_MAPPED_BY_WITH_JOIN_TABLE";	77	public static final String MAPPING_MAPPED_BY_WITH_JOIN_TABLE = "MAPPING_MAPPED_BY_WITH_JOIN_TABLE";
78	public static final String MAPPING_MAPPED_BY_ON_BOTH_SIDES = "MAPPING_MAPPED_BY_ON_BOTH_SIDES";	78	public static final String MAPPING_MAPPED_BY_ON_BOTH_SIDES = "MAPPING_MAPPED_BY_ON_BOTH_SIDES";
79	public static final String ID_MAPPING_UNRESOLVED_GENERATOR_NAME = "ID_MAPPING_UNRESOLVED_GENERATOR_NAME";	79	public static final String ID_MAPPING_UNRESOLVED_GENERATOR_NAME = "ID_MAPPING_UNRESOLVED_GENERATOR_NAME";
		80	public static final String ID_MAPPING_MAPPED_BY_RELATIONSHIP_AND_COLUMN_SPECIFIED = "ID_MAPPING_MAPPED_BY_RELATIONSHIP_AND_COLUMN_SPECIFIED";
		81	public static final String EMBEDDED_ID_MAPPING_MAPPED_BY_RELATIONSHIP_AND_ATTRIBUTE_OVERRIDES_SPECIFIED = "EMBEDDED_ID_MAPPING_MAPPED_BY_RELATIONSHIP_AND_ATTRIBUTE_OVERRIDES_SPECIFIED";
		82	public static final String ATTRIBUTE_OVERRIDE_MAPPED_BY_RELATIONSHIP_AND_SPECIFIED = "ATTRIBUTE_OVERRIDE_MAPPED_BY_RELATIONSHIP_AND_SPECIFIED";
80	public static final String TABLE_UNRESOLVED_CATALOG = "TABLE_UNRESOLVED_CATALOG";	83	public static final String TABLE_UNRESOLVED_CATALOG = "TABLE_UNRESOLVED_CATALOG";
81	public static final String TABLE_UNRESOLVED_SCHEMA = "TABLE_UNRESOLVED_SCHEMA";	84	public static final String TABLE_UNRESOLVED_SCHEMA = "TABLE_UNRESOLVED_SCHEMA";
82	public static final String TABLE_UNRESOLVED_NAME = "TABLE_UNRESOLVED_NAME";	85	public static final String TABLE_UNRESOLVED_NAME = "TABLE_UNRESOLVED_NAME";




		}
		return super.eDerivedStructuralFeatureID(baseFeatureID, baseClass);
	}
	
	
	// ********** translators **********
	
	protected static Translator buildAttributeOverrideTranslator() {
		return XmlAttributeOverride.buildTranslator(JPA.ATTRIBUTE_OVERRIDE, OrmPackage.eINSTANCE.getXmlAttributeOverrideContainer_AttributeOverrides());
	}
}
} // BaseXmlEmbedded




		return MappingKeys.EMBEDDED_ATTRIBUTE_MAPPING_KEY;
	}
	
	
	// ********** translators **********
	
	public static Translator buildTranslator(String elementName, EStructuralFeature structuralFeature) {
		return new SimpleTranslator(elementName, structuralFeature, buildTranslatorChildren());
	}
	
	private static Translator[] buildTranslatorChildren() {
		return new Translator[] {
			buildNameTranslator(),




/*******************************************************************************
 *  Copyright (c) 2010  Oracle. 
 *  All rights reserved.  This program and the accompanying materials are 
 *  made available under the terms of the Eclipse Public License v1.0 which 
 *  accompanies this distribution, and is available at 
 *  http://www.eclipse.org/legal/epl-v10.html
 *  
 *  Contributors: 
 *  	Oracle - initial API and implementation
 *******************************************************************************/
package org.eclipse.jpt.core.jpa2.context;

import org.eclipse.jpt.core.context.IdMapping;

/**
 * Provisional API: This interface is part of an interim API that is still
 * under development and expected to change significantly before reaching
 * stability. It is available at this early stage to solicit feedback from
 * pioneering adopters on the understanding that any code that uses this API
 * will almost certainly be broken (repeatedly) as the API evolves.
 * 
 * @version 2.3
 * @since 2.3
 */
public interface IdMapping2_0
	extends IdMapping
{
	/**
	 * Property string associated with changes to the mapped by relationship
	 */
	final String MAPPED_BY_RELATIONSHIP_PROPERTY = "mappedByRelationship";
	
	/**
	 * Return whether this id is mapped by a relationship (i.e. a relationship maps this id)
	 * N.B. - This might be several relationships (erroneously, of course)
	 */
	boolean isMappedByRelationship();
}




/*******************************************************************************
 *  Copyright (c) 2010  Oracle. 
 *  All rights reserved.  This program and the accompanying materials are 
 *  made available under the terms of the Eclipse Public License v1.0 which 
 *  accompanies this distribution, and is available at 
 *  http://www.eclipse.org/legal/epl-v10.html
 *  
 *  Contributors: 
 *  	Oracle - initial API and implementation
 *******************************************************************************/
package org.eclipse.jpt.core.jpa2.context;

import org.eclipse.jpt.core.context.AttributeOverride;

/**
 * Provisional API: This interface is part of an interim API that is still
 * under development and expected to change significantly before reaching
 * stability. It is available at this early stage to solicit feedback from
 * pioneering adopters on the understanding that any code that uses this API
 * will almost certainly be broken (repeatedly) as the API evolves.
 * 
 * @version 2.3
 * @since 2.3
 */
public interface AttributeOverride2_0
	extends AttributeOverride
{
	/**
	 * Property string associated with changes to the mapped by relationship
	 */
	final String MAPPED_BY_RELATIONSHIP_PROPERTY = "mappedByRelationship";
	
	/**
	 * Return whether this attribute override is mapped by a relationship 
	 * (i.e. a relationship maps this attribute override, possibly in an entity overriding
	 *  an id or an embedded id overriding any attribute)
	 * N.B. - This might be several relationships (erroneously, of course)
	 */
	boolean isMappedByRelationship();
}




/*******************************************************************************
 *  Copyright (c) 2010  Oracle. 
 *  All rights reserved.  This program and the accompanying materials are 
 *  made available under the terms of the Eclipse Public License v1.0 which 
 *  accompanies this distribution, and is available at 
 *  http://www.eclipse.org/legal/epl-v10.html
 *  
 *  Contributors: 
 *  	Oracle - initial API and implementation
 *******************************************************************************/
package org.eclipse.jpt.core.jpa2.context;

import org.eclipse.jpt.core.context.EmbeddedIdMapping;

/**
 * Provisional API: This interface is part of an interim API that is still
 * under development and expected to change significantly before reaching
 * stability. It is available at this early stage to solicit feedback from
 * pioneering adopters on the understanding that any code that uses this API
 * will almost certainly be broken (repeatedly) as the API evolves.
 * 
 * @version 2.3
 * @since 2.3
 */
public interface EmbeddedIdMapping2_0
	extends EmbeddedIdMapping
{
	/**
	 * Property string associated with changes to the mapped by relationship
	 */
	final String MAPPED_BY_RELATIONSHIP_PROPERTY = "mappedByRelationship";
	
	/**
	 * Return whether this id is mapped by a relationship (i.e. a relationship maps this embedded id)
	 * N.B. - This might be several relationships (erroneously, of course)
	 */
	boolean isMappedByRelationship();
}

Return to bug 306777

Lines 704-726 Link Here

(-)src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmMultiRelationshipMapping.java (-17 / +26 lines)
704	}	704	}
705	}	705	}
706		706
707	class MapKeyAttributeOverrideContainerOwner implements OrmAttributeOverrideContainer.Owner {	707	class MapKeyAttributeOverrideContainerOwner
		708	implements OrmAttributeOverrideContainer.Owner
		709	{
708	public OrmTypeMapping getTypeMapping() {	710	public OrmTypeMapping getTypeMapping() {
709	return AbstractOrmMultiRelationshipMapping.this.getTypeMapping();	711	return AbstractOrmMultiRelationshipMapping.this.getTypeMapping();
710	}	712	}
711		713
712	public TypeMapping getOverridableTypeMapping() {	714	public TypeMapping getOverridableTypeMapping() {
713	return AbstractOrmMultiRelationshipMapping.this.getResolvedMapKeyEmbeddable();	715	return AbstractOrmMultiRelationshipMapping.this.getResolvedMapKeyEmbeddable();
714	}	716	}
715		717
		718	public Iterator<String> allOverridableNames() {
		719	TypeMapping typeMapping = getOverridableTypeMapping();
		720	return (typeMapping == null) ?
		721	EmptyIterator.<String>instance()
		722	: typeMapping.allOverridableAttributeNames();
		723	}
		724
716	protected JavaAttributeOverride getJavaAttributeOverrideNamed(String attributeName) {	725	protected JavaAttributeOverride getJavaAttributeOverrideNamed(String attributeName) {
717	return AbstractOrmMultiRelationshipMapping.this.getJavaMapKeyAttributeOverrideNamed(attributeName);	726	return AbstractOrmMultiRelationshipMapping.this.getJavaMapKeyAttributeOverrideNamed(attributeName);
718	}	727	}
719		728
720	public EList<XmlAttributeOverride> getResourceAttributeOverrides() {	729	public EList<XmlAttributeOverride> getResourceAttributeOverrides() {
721	return AbstractOrmMultiRelationshipMapping.this.resourceAttributeMapping.getMapKeyAttributeOverrides();	730	return AbstractOrmMultiRelationshipMapping.this.resourceAttributeMapping.getMapKeyAttributeOverrides();
722	}	731	}
723		732
724	public Column resolveOverriddenColumn(String attributeOverrideName) {	733	public Column resolveOverriddenColumn(String attributeOverrideName) {
725	if (getPersistentAttribute().isVirtual() && !getTypeMapping().isMetadataComplete()) {	734	if (getPersistentAttribute().isVirtual() && !getTypeMapping().isMetadataComplete()) {
726	JavaAttributeOverride javaAttributeOverride = getJavaAttributeOverrideNamed(attributeOverrideName);	735	JavaAttributeOverride javaAttributeOverride = getJavaAttributeOverrideNamed(attributeOverrideName);
Lines 730-741 Link Here
730	}	739	}
731	return MappingTools.resolveOverridenColumn(getOverridableTypeMapping(), attributeOverrideName);	740	return MappingTools.resolveOverridenColumn(getOverridableTypeMapping(), attributeOverrideName);
732	}	741	}
733		742
734		743
735	public XmlColumn buildVirtualXmlColumn(Column overridableColumn, String attributeName, boolean isMetadataComplete) {	744	public XmlColumn buildVirtualXmlColumn(Column overridableColumn, String attributeName, boolean isMetadataComplete) {
736	return new VirtualXmlAttributeOverrideColumn(overridableColumn);	745	return new VirtualXmlAttributeOverrideColumn(overridableColumn);
737	}	746	}
738		747
739	protected OrmJoiningStrategy getPredominantJoiningStrategy() {	748	protected OrmJoiningStrategy getPredominantJoiningStrategy() {
740	return getRelationshipReference().getPredominantJoiningStrategy();	749	return getRelationshipReference().getPredominantJoiningStrategy();
741	}	750	}
Lines 743-757 Link Here
743	public String getDefaultTableName() {	752	public String getDefaultTableName() {
744	return getPredominantJoiningStrategy().getTableName();	753	return getPredominantJoiningStrategy().getTableName();
745	}	754	}
746		755
747	public Table getDbTable(String tableName) {	756	public Table getDbTable(String tableName) {
748	return getPredominantJoiningStrategy().getDbTable(tableName);	757	return getPredominantJoiningStrategy().getDbTable(tableName);
749	}	758	}
750		759
751	public java.util.Iterator<String> candidateTableNames() {	760	public java.util.Iterator<String> candidateTableNames() {
752	return EmptyIterator.instance();	761	return EmptyIterator.instance();
753	}	762	}
754		763
755	/**	764	/**
756	* If there is a specified table name it needs to be the same	765	* If there is a specified table name it needs to be the same
757	* the default table name. the table is always the collection table	766	* the default table name. the table is always the collection table
Lines 759-765 Link Here
759	public boolean tableNameIsInvalid(String tableName) {	768	public boolean tableNameIsInvalid(String tableName) {
760	return !StringTools.stringsAreEqual(getDefaultTableName(), tableName);	769	return !StringTools.stringsAreEqual(getDefaultTableName(), tableName);
761	}	770	}
762		771
763	public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {	772	public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {
764	if (isVirtual()) {	773	if (isVirtual()) {
765	return this.buildVirtualAttributeColumnUnresolvedNameMessage(override.getName(), column, textRange);	774	return this.buildVirtualAttributeColumnUnresolvedNameMessage(override.getName(), column, textRange);
Lines 777-783 Link Here
777	textRange	786	textRange
778	);	787	);
779	}	788	}
780		789
781	protected IMessage buildVirtualAttributeColumnUnresolvedNameMessage(String overrideName, NamedColumn column, TextRange textRange) {	790	protected IMessage buildVirtualAttributeColumnUnresolvedNameMessage(String overrideName, NamedColumn column, TextRange textRange) {
782	return DefaultJpaValidationMessages.buildMessage(	791	return DefaultJpaValidationMessages.buildMessage(
783	IMessage.HIGH_SEVERITY,	792	IMessage.HIGH_SEVERITY,
Lines 791-797 Link Here
791	textRange	800	textRange
792	);	801	);
793	}	802	}
794		803
795	protected IMessage buildVirtualOverrideColumnUnresolvedNameMessage(String overrideName, NamedColumn column, TextRange textRange) {	804	protected IMessage buildVirtualOverrideColumnUnresolvedNameMessage(String overrideName, NamedColumn column, TextRange textRange) {
796	return DefaultJpaValidationMessages.buildMessage(	805	return DefaultJpaValidationMessages.buildMessage(
797	IMessage.HIGH_SEVERITY,	806	IMessage.HIGH_SEVERITY,
Lines 804-810 Link Here
804	textRange	813	textRange
805	);	814	);
806	}	815	}
807		816
808	public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {	817	public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {
809	if (isVirtual()) {	818	if (isVirtual()) {
810	return this.buildVirtualAttributeColumnTableNotValidMessage(override.getName(), column, textRange);	819	return this.buildVirtualAttributeColumnTableNotValidMessage(override.getName(), column, textRange);
Lines 823-829 Link Here
823	textRange	832	textRange
824	);	833	);
825	}	834	}
826		835
827	protected IMessage buildVirtualAttributeColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {	836	protected IMessage buildVirtualAttributeColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
828	return DefaultJpaValidationMessages.buildMessage(	837	return DefaultJpaValidationMessages.buildMessage(
829	IMessage.HIGH_SEVERITY,	838	IMessage.HIGH_SEVERITY,
Lines 838-844 Link Here
838	textRange	847	textRange
839	);	848	);
840	}	849	}
841		850
842	protected IMessage buildVirtualOverrideColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {	851	protected IMessage buildVirtualOverrideColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
843	return DefaultJpaValidationMessages.buildMessage(	852	return DefaultJpaValidationMessages.buildMessage(
844	IMessage.HIGH_SEVERITY,	853	IMessage.HIGH_SEVERITY,
Lines 852-858 Link Here
852	textRange	861	textRange
853	);	862	);
854	}	863	}
855		864
856	public TextRange getValidationTextRange() {	865	public TextRange getValidationTextRange() {
857	return AbstractOrmMultiRelationshipMapping.this.getValidationTextRange();	866	return AbstractOrmMultiRelationshipMapping.this.getValidationTextRange();
858	}	867	}

Lines 753-780 Link Here

(-)src/org/eclipse/jpt/core/internal/context/java/AbstractJavaMultiRelationshipMapping.java (-11 / +17 lines)
753	extends OverrideContainerOwner	753	extends OverrideContainerOwner
754	implements JavaAttributeOverrideContainer.Owner	754	implements JavaAttributeOverrideContainer.Owner
755	{	755	{
756		756	public TypeMapping getOverridableTypeMapping() {
		757	return AbstractJavaMultiRelationshipMapping.this.getResolvedMapKeyEmbeddable();
		758	}
		759
		760	public Iterator<String> allOverridableNames() {
		761	TypeMapping typeMapping = getOverridableTypeMapping();
		762	return (typeMapping == null) ?
		763	EmptyIterator.<String>instance()
		764	: typeMapping.allOverridableAttributeNames();
		765	}
		766
757	public String getPossiblePrefix() {	767	public String getPossiblePrefix() {
758	return "key."; //$NON-NLS-1$	768	return "key."; //$NON-NLS-1$
759	}	769	}
760		770
761	public String getWritePrefix() {	771	public String getWritePrefix() {
762	return this.getPossiblePrefix();	772	return this.getPossiblePrefix();
763	}	773	}
764		774
765	//since only the key can be an embeddable on a 1-m or m-m, all overrides are relevant	775	//since only the key can be an embeddable on a 1-m or m-m, all overrides are relevant
766	public boolean isRelevant(String overrideName) {	776	public boolean isRelevant(String overrideName) {
767	return true;	777	return true;
768	}	778	}
769		779
770	public TypeMapping getOverridableTypeMapping() {
771	return AbstractJavaMultiRelationshipMapping.this.getResolvedMapKeyEmbeddable();
772	}
773
774	public Column resolveOverriddenColumn(String attributeOverrideName) {	780	public Column resolveOverriddenColumn(String attributeOverrideName) {
775	return MappingTools.resolveOverridenColumn(getOverridableTypeMapping(), attributeOverrideName);	781	return MappingTools.resolveOverridenColumn(getOverridableTypeMapping(), attributeOverrideName);
776	}	782	}
777		783
778	public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {	784	public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {
779	if (override.isVirtual()) {	785	if (override.isVirtual()) {
780	return this.buildVirtualColumnUnresolvedNameMessage(override.getName(), column, textRange);	786	return this.buildVirtualColumnUnresolvedNameMessage(override.getName(), column, textRange);
Lines 797-803 Link Here
797	textRange	803	textRange
798	);	804	);
799	}	805	}
800		806
801	public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {	807	public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {
802	if (override.isVirtual()) {	808	if (override.isVirtual()) {
803	return this.buildVirtualColumnTableNotValidMessage(override.getName(), column, textRange);	809	return this.buildVirtualColumnTableNotValidMessage(override.getName(), column, textRange);
Lines 810-816 Link Here
810	textRange	816	textRange
811	);	817	);
812	}	818	}
813		819
814	protected IMessage buildVirtualColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {	820	protected IMessage buildVirtualColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
815	return DefaultJpaValidationMessages.buildMessage(	821	return DefaultJpaValidationMessages.buildMessage(
816	IMessage.HIGH_SEVERITY,	822	IMessage.HIGH_SEVERITY,

Lines 10-40 Link Here

(-)src/org/eclipse/jpt/eclipselink/ui/internal/v2_0/details/orm/OrmEclipseLinkIdMapping2_0Composite.java (-14 / +23 lines)
10	package org.eclipse.jpt.eclipselink.ui.internal.v2_0.details.orm;	10	package org.eclipse.jpt.eclipselink.ui.internal.v2_0.details.orm;
11		11
12	import org.eclipse.jpt.core.context.orm.OrmIdMapping;	12	import org.eclipse.jpt.core.context.orm.OrmIdMapping;
		13	import org.eclipse.jpt.eclipselink.ui.internal.details.EclipseLinkMutableComposite;
13	import org.eclipse.jpt.eclipselink.ui.internal.v1_1.details.orm.OrmEclipseLinkIdMapping1_1Composite;	14	import org.eclipse.jpt.eclipselink.ui.internal.v1_1.details.orm.OrmEclipseLinkIdMapping1_1Composite;
14	import org.eclipse.jpt.ui.WidgetFactory;	15	import org.eclipse.jpt.ui.WidgetFactory;
		16	import org.eclipse.jpt.ui.internal.details.AccessTypeComposite;
		17	import org.eclipse.jpt.ui.internal.details.ColumnComposite;
		18	import org.eclipse.jpt.ui.internal.details.orm.OrmMappingNameChooser;
		19	import org.eclipse.jpt.ui.internal.jpa2.details.IdMapping2_0MappedByRelationshipPane;
15	import org.eclipse.jpt.ui.internal.jpa2.details.IdMappingGeneration2_0Composite;	20	import org.eclipse.jpt.ui.internal.jpa2.details.IdMappingGeneration2_0Composite;
16	import org.eclipse.jpt.utility.model.value.PropertyValueModel;	21	import org.eclipse.jpt.utility.model.value.PropertyValueModel;
17	import org.eclipse.swt.widgets.Composite;	22	import org.eclipse.swt.widgets.Composite;
18		23
19	public class OrmEclipseLinkIdMapping2_0Composite extends OrmEclipseLinkIdMapping1_1Composite	24	public class OrmEclipseLinkIdMapping2_0Composite
		25	extends OrmEclipseLinkIdMapping1_1Composite
20	{	26	{
21	/**	27	public OrmEclipseLinkIdMapping2_0Composite(
22	* Creates a new <code>public</code>.	28	PropertyValueModel<? extends OrmIdMapping> subjectHolder,
23	*	29	Composite parent,
24	* @param subjectHolder The holder of the subject <code>IdMapping</code>	30	WidgetFactory widgetFactory) {
25	* @param parent The parent container	31
26	* @param widgetFactory The factory used to create various common widgets
27	*/
28	public OrmEclipseLinkIdMapping2_0Composite(PropertyValueModel<? extends OrmIdMapping> subjectHolder,
29	Composite parent,
30	WidgetFactory widgetFactory) {
31
32	super(subjectHolder, parent, widgetFactory);	32	super(subjectHolder, parent, widgetFactory);
33	}	33	}
34		34
		35
		36	@Override
		37	protected void initializeIdSection(Composite container) {
		38	new IdMapping2_0MappedByRelationshipPane(this, getSubjectHolder(), container);
		39	new ColumnComposite(this, buildColumnHolder(), container);
		40	new OrmMappingNameChooser(this, getSubjectHolder(), container);
		41	new AccessTypeComposite(this, buildAccessHolderHolder(), container);
		42	new EclipseLinkMutableComposite(this, buildMutableHolder(), container);
		43	}
		44
35	@Override	45	@Override
36	protected void initializeGenerationCollapsibleSection(Composite container) {	46	protected void initializeGenerationCollapsibleSection(Composite container) {
37	new IdMappingGeneration2_0Composite(this, container);	47	new IdMappingGeneration2_0Composite(this, container);
38	}	48	}
39		49	}
40	}

Lines 22-53 Link Here

(-)src/org/eclipse/jpt/eclipselink/ui/internal/details/orm/OrmEclipseLinkIdMappingComposite.java (-14 / +10 lines)
22		22
23	//Remove the Converters section from 1.0 orm id mappings.	23	//Remove the Converters section from 1.0 orm id mappings.
24	//This is supported in EclipseLink in version 1.1, but not 1.0	24	//This is supported in EclipseLink in version 1.1, but not 1.0
25	public class OrmEclipseLinkIdMappingComposite extends EclipseLinkIdMappingComposite<OrmIdMapping>	25	public class OrmEclipseLinkIdMappingComposite
		26	extends EclipseLinkIdMappingComposite<OrmIdMapping>
26	{	27	{
27	/**	28	public OrmEclipseLinkIdMappingComposite(
28	* Creates a new <code>EclipseLinkOrmIdMappingComposite</code>.	29	PropertyValueModel<? extends OrmIdMapping> subjectHolder,
29	*	30	Composite parent,
30	* @param subjectHolder The holder of the subject <code>IdMapping</code>	31	WidgetFactory widgetFactory) {
31	* @param parent The parent container	32
32	* @param widgetFactory The factory used to create various common widgets
33	*/
34	public OrmEclipseLinkIdMappingComposite(PropertyValueModel<? extends OrmIdMapping> subjectHolder,
35	Composite parent,
36	WidgetFactory widgetFactory) {
37
38	super(subjectHolder, parent, widgetFactory);	33	super(subjectHolder, parent, widgetFactory);
39	}	34	}
40		35
		36
41	@Override	37	@Override
42	protected void initializeIdSection(Composite container) {	38	protected void initializeIdSection(Composite container) {
43	new ColumnComposite(this, buildColumnHolder(), container);	39	new ColumnComposite(this, buildColumnHolder(), container);
44	new OrmMappingNameChooser(this, getSubjectHolder(), container);	40	new OrmMappingNameChooser(this, getSubjectHolder(), container);
45	new EclipseLinkMutableComposite(this, buildMutableHolder(), container);	41	new EclipseLinkMutableComposite(this, buildMutableHolder(), container);
46	}	42	}
47		43
48	@Override	44	@Override
49	//everything but the 'Define Converter' section. This is not supported in eclipselink 1.0, but is in 1.1	45	//everything but the 'Define Converter' section. This is not supported in eclipselink 1.0, but is in 1.1
50	protected Pane<EclipseLinkConvert> buildConvertComposite(PropertyValueModel<EclipseLinkConvert> convertHolder, Composite container) {	46	protected Pane<EclipseLinkConvert> buildConvertComposite(PropertyValueModel<EclipseLinkConvert> convertHolder, Composite container) {
51	return new OrmEclipseLinkConvert1_0Composite(convertHolder, container, getWidgetFactory());	47	return new OrmEclipseLinkConvert1_0Composite(convertHolder, container, getWidgetFactory());
52	}	48	}
53	}	49	}

Added Link Here

(-)src/org/eclipse/jpt/eclipselink/ui/internal/v2_0/details/orm/OrmEclipseLinkEmbeddedIdMapping2_0Composite.java (+43 lines)
1	/*******************************************************************************
2	* Copyright (c) 2010 Oracle.
3	* All rights reserved. This program and the accompanying materials are
4	* made available under the terms of the Eclipse Public License v1.0 which
5	* accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Oracle - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.jpt.eclipselink.ui.internal.v2_0.details.orm;
12
13	import org.eclipse.jpt.core.context.orm.OrmEmbeddedIdMapping;
14	import org.eclipse.jpt.eclipselink.ui.internal.v1_1.details.orm.OrmEclipseLinkEmbeddedIdMapping1_1Composite;
15	import org.eclipse.jpt.ui.WidgetFactory;
16	import org.eclipse.jpt.ui.internal.details.AccessTypeComposite;
17	import org.eclipse.jpt.ui.internal.details.EmbeddedMappingOverridesComposite;
18	import org.eclipse.jpt.ui.internal.details.orm.OrmMappingNameChooser;
19	import org.eclipse.jpt.ui.internal.jpa2.details.EmbeddedIdMapping2_0MappedByRelationshipPane;
20	import org.eclipse.jpt.utility.model.value.PropertyValueModel;
21	import org.eclipse.swt.widgets.Composite;
22
23	public class OrmEclipseLinkEmbeddedIdMapping2_0Composite
24	extends OrmEclipseLinkEmbeddedIdMapping1_1Composite
25	{
26	public OrmEclipseLinkEmbeddedIdMapping2_0Composite(
27	PropertyValueModel<? extends OrmEmbeddedIdMapping> subjectHolder,
28	Composite parent,
29	WidgetFactory widgetFactory) {
30
31	super(subjectHolder, parent, widgetFactory);
32	}
33
34
35	@Override
36	protected void initializeEmbeddedIdSection(Composite container) {
37	new OrmMappingNameChooser(this, getSubjectHolder(), container);
38	new AccessTypeComposite(this, buildAccessHolderHolder(), container);
39
40	new EmbeddedIdMapping2_0MappedByRelationshipPane(this, getSubjectHolder(), container);
41	new EmbeddedMappingOverridesComposite(this, container);
42	}
43	}

Lines 10-16 Link Here

(-)src/org/eclipse/jpt/ui/internal/details/AbstractEmbeddedIdMappingComposite.java (-41 / +13 lines)
10	package org.eclipse.jpt.ui.internal.details;	10	package org.eclipse.jpt.ui.internal.details;
11		11
12	import org.eclipse.jpt.core.context.EmbeddedIdMapping;	12	import org.eclipse.jpt.core.context.EmbeddedIdMapping;
13	import org.eclipse.jpt.core.context.EmbeddedMapping;
14	import org.eclipse.jpt.ui.WidgetFactory;	13	import org.eclipse.jpt.ui.WidgetFactory;
15	import org.eclipse.jpt.ui.details.JpaComposite;	14	import org.eclipse.jpt.ui.details.JpaComposite;
16	import org.eclipse.jpt.ui.internal.widgets.Pane;	15	import org.eclipse.jpt.ui.internal.widgets.Pane;
Lines 18-57 Link Here
18	import org.eclipse.jpt.utility.model.value.PropertyValueModel;	17	import org.eclipse.jpt.utility.model.value.PropertyValueModel;
19	import org.eclipse.swt.widgets.Composite;	18	import org.eclipse.swt.widgets.Composite;
20		19
21	/**
22	* Here the layout of this pane:
23	* <pre>
24	* -----------------------------------------------------------------------------
25	* \| ------------------------------------------------------------------------- \|
26	* \| \| \| \|
27	* \| \| EmbeddedAttributeOverridesComposite \| \|
28	* \| \| \| \|
29	* \| ------------------------------------------------------------------------- \|
30	* -----------------------------------------------------------------------------</pre>
31	*
32	* @see EmbeddedMapping
33	*
34	* @version 2.3
35	* @since 1.0
36	*/
37	public abstract class AbstractEmbeddedIdMappingComposite<T extends EmbeddedIdMapping>	20	public abstract class AbstractEmbeddedIdMappingComposite<T extends EmbeddedIdMapping>
38	extends Pane<T>	21	extends Pane<T>
39	implements JpaComposite	22	implements JpaComposite
40	{	23	{
41	/**	24	protected AbstractEmbeddedIdMappingComposite(
42	* Creates a new <code>EmbeddedMappingComposite</code>.	25	PropertyValueModel<? extends T> subjectHolder,
43	*	26	Composite parent,
44	* @param subjectHolder The holder of the subject <code>EmbeddedMapping</code>	27	WidgetFactory widgetFactory) {
45	* @param parent The parent container	28
46	* @param widgetFactory The factory used to create various common widgets
47	*/
48	protected AbstractEmbeddedIdMappingComposite(PropertyValueModel<? extends T> subjectHolder,
49	Composite parent,
50	WidgetFactory widgetFactory) {
51
52	super(subjectHolder, parent, widgetFactory);	29	super(subjectHolder, parent, widgetFactory);
53	}	30	}
54		31
		32
55	@Override	33	@Override
56	protected void initializeLayout(Composite container) {	34	protected void initializeLayout(Composite container) {
57	initializeEmbeddedIdCollapsibleSection(container);	35	initializeEmbeddedIdCollapsibleSection(container);
Lines 59-76 Link Here
59		37
60	protected void initializeEmbeddedIdCollapsibleSection(Composite container) {	38	protected void initializeEmbeddedIdCollapsibleSection(Composite container) {
61	container = addCollapsibleSection(	39	container = addCollapsibleSection(
62	container,	40	container,
63	JptUiDetailsMessages.EmbeddedIdSection_title,	41	JptUiDetailsMessages.EmbeddedIdSection_title,
64	new SimplePropertyValueModel<Boolean>(Boolean.TRUE)	42	new SimplePropertyValueModel<Boolean>(Boolean.TRUE));
65	);	43
66
67	this.initializeEmbeddedIdSection(container);	44	this.initializeEmbeddedIdSection(container);
68	}	45	}
69		46
70	protected void initializeEmbeddedIdSection(Composite container) {	47	protected abstract void initializeEmbeddedIdSection(Composite container);
71	new EmbeddedMappingOverridesComposite(	48	}
72	this,
73	container
74	);
75	}
76	}

Lines 27-79 Link Here

(-)src/org/eclipse/jpt/ui/internal/details/AbstractIdMappingComposite.java (-66 / +29 lines)
27	import org.eclipse.swt.widgets.Button;	27	import org.eclipse.swt.widgets.Button;
28	import org.eclipse.swt.widgets.Composite;	28	import org.eclipse.swt.widgets.Composite;
29		29
30	/**
31	* Here the layout of this pane:
32	* <pre>
33	* -----------------------------------------------------------------------------
34	* \| ------------------------------------------------------------------------- \|
35	* \| \| \| \|
36	* \| \| ColumnComposite \| \|
37	* \| \| \| \|
38	* \| ------------------------------------------------------------------------- \|
39	* \| ------------------------------------------------------------------------- \|
40	* \| \| \| \|
41	* \| \| TemporalTypeComposite \| \|
42	* \| \| \| \|
43	* \| ------------------------------------------------------------------------- \|
44	* \| ------------------------------------------------------------------------- \|
45	* \| \| \| \|
46	* \| \| GenerationComposite \| \|
47	* \| \| \| \|
48	* \| ------------------------------------------------------------------------- \|
49	* -----------------------------------------------------------------------------</pre>
50	*
51	* @see IdMapping
52	* @see ColumnComposite
53	* @see TemporalTypeComposite
54	* @see IdMappingGenerationComposite
55	*
56	* @version 2.3
57	* @since 1.0
58	*/
59	public abstract class AbstractIdMappingComposite<T extends IdMapping>	30	public abstract class AbstractIdMappingComposite<T extends IdMapping>
60	extends Pane<T>	31	extends Pane<T>
61	implements JpaComposite	32	implements JpaComposite
62	{	33	{
63	/**	34	public AbstractIdMappingComposite(
64	* Creates a new <code>IdMappingComposite</code>.	35	PropertyValueModel<? extends T> subjectHolder,
65	*	36	Composite parent,
66	* @param subjectHolder The holder of the subject <code>IIdMapping</code>	37	WidgetFactory widgetFactory) {
67	* @param parent The parent container	38
68	* @param widgetFactory The factory used to create various common widgets
69	*/
70	public AbstractIdMappingComposite(PropertyValueModel<? extends T> subjectHolder,
71	Composite parent,
72	WidgetFactory widgetFactory) {
73
74	super(subjectHolder, parent, widgetFactory);	39	super(subjectHolder, parent, widgetFactory);
75	}	40	}
76		41
		42
77	@Override	43	@Override
78	protected void initializeLayout(Composite container) {	44	protected void initializeLayout(Composite container) {
79	initializeIdCollapsibleSection(container);	45	initializeIdCollapsibleSection(container);
Lines 83-131 Link Here
83		49
84	protected void initializeIdCollapsibleSection(Composite container) {	50	protected void initializeIdCollapsibleSection(Composite container) {
85	container = addCollapsibleSection(	51	container = addCollapsibleSection(
86	container,	52	container,
87	JptUiDetailsMessages.IdSection_title,	53	JptUiDetailsMessages.IdSection_title,
88	new SimplePropertyValueModel<Boolean>(Boolean.TRUE)	54	new SimplePropertyValueModel<Boolean>(Boolean.TRUE));
89	);
90		55
91	this.initializeIdSection(container);	56	this.initializeIdSection(container);
92	}	57	}
93		58
94	protected abstract void initializeIdSection(Composite container);	59	protected abstract void initializeIdSection(Composite container);
95		60
96	protected void initializeTypeCollapsibleSection(Composite container) {	61	protected void initializeTypeCollapsibleSection(Composite container) {
97	container = addCollapsibleSection(	62	container = addCollapsibleSection(
98	container,	63	container,
99	JptUiDetailsMessages.TypeSection_type	64	JptUiDetailsMessages.TypeSection_type);
100	);
101	this.initializeTypeSection(container);	65	this.initializeTypeSection(container);
102	}	66	}
103		67
104	protected void initializeTypeSection(Composite container) {	68	protected void initializeTypeSection(Composite container) {
105	((GridLayout) container.getLayout()).numColumns = 2;	69	((GridLayout) container.getLayout()).numColumns = 2;
106		70
107	// No converter	71	// No converter
108	Button noConverterButton = addRadioButton(	72	Button noConverterButton = addRadioButton(
109	container,	73	container,
110	JptUiDetailsMessages.TypeSection_default,	74	JptUiDetailsMessages.TypeSection_default,
111	buildConverterBooleanHolder(Converter.NO_CONVERTER),	75	buildConverterBooleanHolder(Converter.NO_CONVERTER),
112	null);	76	null);
113	((GridData) noConverterButton.getLayoutData()).horizontalSpan = 2;	77	((GridData) noConverterButton.getLayoutData()).horizontalSpan = 2;
114		78
115	PropertyValueModel<Converter> converterHolder = buildConverterHolder();	79	PropertyValueModel<Converter> converterHolder = buildConverterHolder();
116	// Temporal	80	// Temporal
117	addRadioButton(	81	addRadioButton(
118	container,	82	container,
119	JptUiDetailsMessages.TypeSection_temporal,	83	JptUiDetailsMessages.TypeSection_temporal,
120	buildConverterBooleanHolder(Converter.TEMPORAL_CONVERTER),	84	buildConverterBooleanHolder(Converter.TEMPORAL_CONVERTER),
121	null);	85	null);
122	registerSubPane(new TemporalTypeComposite(buildTemporalConverterHolder(converterHolder), container, getWidgetFactory()));	86	registerSubPane(new TemporalTypeComposite(buildTemporalConverterHolder(converterHolder), container, getWidgetFactory()));
123	}	87	}
124		88
125	protected void initializeGenerationCollapsibleSection(Composite container) {	89	protected void initializeGenerationCollapsibleSection(Composite container) {
126	new IdMappingGenerationComposite(this, container);	90	new IdMappingGenerationComposite(this, container);
127	}	91	}
128		92
129	protected PropertyValueModel<? extends Column> buildColumnHolder() {	93	protected PropertyValueModel<? extends Column> buildColumnHolder() {
130	return new TransformationPropertyValueModel<T, Column>(getSubjectHolder()) {	94	return new TransformationPropertyValueModel<T, Column>(getSubjectHolder()) {
131	@Override	95	@Override
Lines 134-140 Link Here
134	}	98	}
135	};	99	};
136	}	100	}
137		101
138	protected WritablePropertyValueModel<Boolean> buildConverterBooleanHolder(final String converterType) {	102	protected WritablePropertyValueModel<Boolean> buildConverterBooleanHolder(final String converterType) {
139	return new PropertyAspectAdapter<T, Boolean>(getSubjectHolder(), ConvertibleMapping.CONVERTER_PROPERTY) {	103	return new PropertyAspectAdapter<T, Boolean>(getSubjectHolder(), ConvertibleMapping.CONVERTER_PROPERTY) {
140	@Override	104	@Override
Lines 142-148 Link Here
142	Converter converter = this.subject.getConverter();	106	Converter converter = this.subject.getConverter();
143	return Boolean.valueOf(converter.getType() == converterType);	107	return Boolean.valueOf(converter.getType() == converterType);
144	}	108	}
145		109
146	@Override	110	@Override
147	protected void setValue_(Boolean value) {	111	protected void setValue_(Boolean value) {
148	if (value.booleanValue()) {	112	if (value.booleanValue()) {
Lines 151-158 Link Here
151	}	115	}
152	};	116	};
153	}	117	}
154		118
155
156	protected PropertyValueModel<Converter> buildConverterHolder() {	119	protected PropertyValueModel<Converter> buildConverterHolder() {
157	return new PropertyAspectAdapter<T, Converter>(getSubjectHolder(), ConvertibleMapping.CONVERTER_PROPERTY) {	120	return new PropertyAspectAdapter<T, Converter>(getSubjectHolder(), ConvertibleMapping.CONVERTER_PROPERTY) {
158	@Override	121	@Override
Lines 170-173 Link Here
170	}	133	}
171	};	134	};
172	}	135	}
173	}	136	}

Lines 10-15 Link Here

(-)src/org/eclipse/jpt/ui/internal/jpa2/details/java/Generic2_0JavaUiFactory.java (-1 / +15 lines)
10	package org.eclipse.jpt.ui.internal.jpa2.details.java;	10	package org.eclipse.jpt.ui.internal.jpa2.details.java;
11		11
12	import org.eclipse.jpt.core.context.java.JavaEmbeddable;	12	import org.eclipse.jpt.core.context.java.JavaEmbeddable;
		13	import org.eclipse.jpt.core.context.java.JavaEmbeddedIdMapping;
13	import org.eclipse.jpt.core.context.java.JavaEmbeddedMapping;	14	import org.eclipse.jpt.core.context.java.JavaEmbeddedMapping;
14	import org.eclipse.jpt.core.context.java.JavaEntity;	15	import org.eclipse.jpt.core.context.java.JavaEntity;
15	import org.eclipse.jpt.core.context.java.JavaIdMapping;	16	import org.eclipse.jpt.core.context.java.JavaIdMapping;
Lines 23-28 Link Here
23	import org.eclipse.jpt.ui.details.JpaComposite;	24	import org.eclipse.jpt.ui.details.JpaComposite;
24	import org.eclipse.jpt.ui.internal.details.java.BaseJavaUiFactory;	25	import org.eclipse.jpt.ui.internal.details.java.BaseJavaUiFactory;
25	import org.eclipse.jpt.ui.internal.jpa2.details.ElementCollectionMapping2_0Composite;	26	import org.eclipse.jpt.ui.internal.jpa2.details.ElementCollectionMapping2_0Composite;
		27	import org.eclipse.jpt.ui.internal.jpa2.details.EmbeddedIdMapping2_0Composite;
26	import org.eclipse.jpt.ui.internal.persistence.details.GenericPersistenceXmlUiFactory;	28	import org.eclipse.jpt.ui.internal.persistence.details.GenericPersistenceXmlUiFactory;
27	import org.eclipse.jpt.ui.jpa2.details.java.JavaUiFactory2_0;	29	import org.eclipse.jpt.ui.jpa2.details.java.JavaUiFactory2_0;
28	import org.eclipse.jpt.utility.model.value.PropertyValueModel;	30	import org.eclipse.jpt.utility.model.value.PropertyValueModel;
Lines 41-46 Link Here
41	extends BaseJavaUiFactory	43	extends BaseJavaUiFactory
42	implements JavaUiFactory2_0	44	implements JavaUiFactory2_0
43	{	45	{
		46	// ************** java type mapping composites *************************
44		47
45	@Override	48	@Override
46	public JpaComposite createJavaMappedSuperclassComposite(	49	public JpaComposite createJavaMappedSuperclassComposite(
Lines 62-68 Link Here
62	Composite parent, WidgetFactory widgetFactory) {	65	Composite parent, WidgetFactory widgetFactory) {
63	return new JavaEmbeddable2_0Composite(subjectHolder, parent, widgetFactory);	66	return new JavaEmbeddable2_0Composite(subjectHolder, parent, widgetFactory);
64	}	67	}
65		68
		69
		70	// ************** java attribute mapping composites ********************
		71
66	@Override	72	@Override
67	public JpaComposite createJavaIdMappingComposite(	73	public JpaComposite createJavaIdMappingComposite(
68	PropertyValueModel<JavaIdMapping> subjectHolder,	74	PropertyValueModel<JavaIdMapping> subjectHolder,
Lines 72-77 Link Here
72	}	78	}
73		79
74	@Override	80	@Override
		81	public JpaComposite createJavaEmbeddedIdMappingComposite(
		82	PropertyValueModel<JavaEmbeddedIdMapping> subjectHolder,
		83	Composite parent,
		84	WidgetFactory widgetFactory) {
		85	return new EmbeddedIdMapping2_0Composite(subjectHolder, parent, widgetFactory);
		86	}
		87
		88	@Override
75	public JpaComposite createJavaEmbeddedMappingComposite(	89	public JpaComposite createJavaEmbeddedMappingComposite(
76	PropertyValueModel<JavaEmbeddedMapping> subjectHolder,	90	PropertyValueModel<JavaEmbeddedMapping> subjectHolder,
77	Composite parent,	91	Composite parent,

Lines 28-37 Link Here

(-)property_files/jpt_ui_details.properties (-6 / +6 lines)
28		28
29	BasicSection_title=Basic	29	BasicSection_title=Basic
30	EmbeddedSection_title=Embedded	30	EmbeddedSection_title=Embedded
31	EmbeddedIdSection_title=Embedded Id	31	EmbeddedIdSection_title=Embedded ID
32	EmbeddableSection_title=Embeddable	32	EmbeddableSection_title=Embeddable
33	EntitySection_title=Entity	33	EntitySection_title=Entity
34	IdSection_title=Id	34	IdSection_title=ID
35	ManyToManySection_title=Many to Many	35	ManyToManySection_title=Many to Many
36	ManyToOneSection_title=Many to One	36	ManyToOneSection_title=Many to One
37	MappedSuperclassSection_title=Mapped Superclass	37	MappedSuperclassSection_title=Mapped Superclass
Lines 41-48 Link Here
41		41
42	BasicMappingUiProvider_label=Basic	42	BasicMappingUiProvider_label=Basic
43	EmbeddedMappingUiProvider_label=Embedded	43	EmbeddedMappingUiProvider_label=Embedded
44	EmbeddedIdMappingUiProvider_label=Embedded Id	44	EmbeddedIdMappingUiProvider_label=Embedded ID
45	IdMappingUiProvider_label=Id	45	IdMappingUiProvider_label=ID
46	OneToManyMappingUiProvider_label=One to Many	46	OneToManyMappingUiProvider_label=One to Many
47	OneToOneMappingUiProvider_label=One to One	47	OneToOneMappingUiProvider_label=One to One
48	ManyToManyMappingUiProvider_label=Many to Many	48	ManyToManyMappingUiProvider_label=Many to Many
Lines 51-58 Link Here
51	VersionMappingUiProvider_label=Version	51	VersionMappingUiProvider_label=Version
52	BasicMappingUiProvider_linkLabel=basic	52	BasicMappingUiProvider_linkLabel=basic
53	EmbeddedMappingUiProvider_linkLabel=embedded	53	EmbeddedMappingUiProvider_linkLabel=embedded
54	EmbeddedIdMappingUiProvider_linkLabel=embedded id	54	EmbeddedIdMappingUiProvider_linkLabel=embedded ID
55	IdMappingUiProvider_linkLabel=id	55	IdMappingUiProvider_linkLabel=ID
56	OneToManyMappingUiProvider_linkLabel=one to many	56	OneToManyMappingUiProvider_linkLabel=one to many
57	OneToOneMappingUiProvider_linkLabel=one to one	57	OneToOneMappingUiProvider_linkLabel=one to one
58	ManyToManyMappingUiProvider_linkLabel=many to many	58	ManyToManyMappingUiProvider_linkLabel=many to many

Lines 23-63 Link Here

(-)src/org/eclipse/jpt/ui/internal/details/db/ColumnCombo.java (-16 / +19 lines)
23	public abstract class ColumnCombo<T extends JpaNode>	23	public abstract class ColumnCombo<T extends JpaNode>
24	extends DatabaseObjectCombo<T>	24	extends DatabaseObjectCombo<T>
25	{	25	{
26	public ColumnCombo(Pane<? extends T> parentPane, Composite parent) {	26	public ColumnCombo(
		27	Pane<? extends T> parentPane,
		28	Composite parent) {
		29
27	super(parentPane, parent);	30	super(parentPane, parent);
28	}	31	}
29		32
30	public ColumnCombo(	33	public ColumnCombo(
31	Pane<?> parentPane,	34	Pane<?> parentPane,
32	PropertyValueModel<? extends T> subjectHolder,	35	PropertyValueModel<? extends T> subjectHolder,
33	Composite parent	36	Composite parent) {
34	) {	37
35	super(parentPane, subjectHolder, parent);	38	super(parentPane, subjectHolder, parent);
36	}	39	}
37		40
38	public ColumnCombo(	41	public ColumnCombo(
39	PropertyValueModel<? extends T> subjectHolder,	42	PropertyValueModel<? extends T> subjectHolder,
40	Composite parent,	43	Composite parent,
41	WidgetFactory widgetFactory	44	WidgetFactory widgetFactory) {
42	) {	45
43	super(subjectHolder, parent, widgetFactory);	46	super(subjectHolder, parent, widgetFactory);
44	}	47	}
45		48
		49
46	@Override	50	@Override
47	protected Iterable<String> getValues_() {	51	protected Iterable<String> getValues_() {
48	Table dbTable = this.getDbTable();	52	Table dbTable = this.getDbTable();
49	return (dbTable != null) ? dbTable.getSortedColumnIdentifiers() : EmptyIterable.<String>instance();	53	return (dbTable != null) ? dbTable.getSortedColumnIdentifiers() : EmptyIterable.<String>instance();
50	}	54	}
51		55
52	protected Table getDbTable() {	56	protected Table getDbTable() {
53	return (this.getSubject() == null) ? null : this.getDbTable_();	57	return (this.getSubject() == null) ? null : this.getDbTable_();
54	}	58	}
55		59
56	/**	60	/**
57	* Assume the subject is not null.	61	* Assume the subject is not null.
58	*/	62	*/
59	protected abstract Table getDbTable_();	63	protected abstract Table getDbTable_();
60		64
61	@Override	65	@Override
62	protected void tableChanged_(Table table) {	66	protected void tableChanged_(Table table) {
63	super.tableChanged_(table);	67	super.tableChanged_(table);
Lines 65-69 Link Here
65	this.doPopulate();	69	this.doPopulate();
66	}	70	}
67	}	71	}
68
69	}	72	}

Lines 23-54 Link Here

(-)src/org/eclipse/jpt/ui/internal/details/db/TableCombo.java (-13 / +17 lines)
23	public abstract class TableCombo<T extends JpaNode>	23	public abstract class TableCombo<T extends JpaNode>
24	extends DatabaseObjectCombo<T>	24	extends DatabaseObjectCombo<T>
25	{	25	{
26	public TableCombo(Pane<? extends T> parentPane, Composite parent) {	26	public TableCombo(
		27	Pane<? extends T> parentPane,
		28	Composite parent) {
		29
27	super(parentPane, parent);	30	super(parentPane, parent);
28	}	31	}
29		32
30	public TableCombo(	33	public TableCombo(
31	Pane<?> parentPane,	34	Pane<?> parentPane,
32	PropertyValueModel<? extends T> subjectHolder,	35	PropertyValueModel<? extends T> subjectHolder,
33	Composite parent	36	Composite parent) {
34	) {	37
35	super(parentPane, subjectHolder, parent);	38	super(parentPane, subjectHolder, parent);
36	}	39	}
37		40
38	public TableCombo(	41	public TableCombo(
39	PropertyValueModel<? extends T> subjectHolder,	42	PropertyValueModel<? extends T> subjectHolder,
40	Composite parent,	43	Composite parent,
41	WidgetFactory widgetFactory	44	WidgetFactory widgetFactory) {
42	) {	45
43	super(subjectHolder, parent, widgetFactory);	46	super(subjectHolder, parent, widgetFactory);
44	}	47	}
45		48
		49
46	@Override	50	@Override
47	protected Iterable<String> getValues_() {	51	protected Iterable<String> getValues_() {
48	Schema dbSchema = this.getDbSchema();	52	Schema dbSchema = this.getDbSchema();
49	return (dbSchema != null) ? dbSchema.getSortedTableIdentifiers() : EmptyIterable.<String>instance();	53	return (dbSchema != null) ? dbSchema.getSortedTableIdentifiers() : EmptyIterable.<String>instance();
50	}	54	}
51		55
52	protected Schema getDbSchema() {	56	protected Schema getDbSchema() {
53	return (this.getSubject() == null) ? null : this.getDbSchema_();	57	return (this.getSubject() == null) ? null : this.getDbSchema_();
54	}	58	}

Lines 10-15 Link Here

(-)src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmEntity.java (-27 / +79 lines)
10	package org.eclipse.jpt.core.internal.context.orm;	10	package org.eclipse.jpt.core.internal.context.orm;
11		11
12	import java.util.ArrayList;	12	import java.util.ArrayList;
		13	import java.util.Collection;
13	import java.util.Iterator;	14	import java.util.Iterator;
14	import java.util.List;	15	import java.util.List;
15	import java.util.ListIterator;	16	import java.util.ListIterator;
Lines 65-70 Link Here
65	import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages;	66	import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages;
66	import org.eclipse.jpt.core.internal.validation.JpaValidationDescriptionMessages;	67	import org.eclipse.jpt.core.internal.validation.JpaValidationDescriptionMessages;
67	import org.eclipse.jpt.core.internal.validation.JpaValidationMessages;	68	import org.eclipse.jpt.core.internal.validation.JpaValidationMessages;
		69	import org.eclipse.jpt.core.jpa2.context.SingleRelationshipMapping2_0;
68	import org.eclipse.jpt.core.jpa2.context.orm.OrmCacheableHolder2_0;	70	import org.eclipse.jpt.core.jpa2.context.orm.OrmCacheableHolder2_0;
69	import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType;	71	import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType;
70	import org.eclipse.jpt.core.resource.orm.Inheritance;	72	import org.eclipse.jpt.core.resource.orm.Inheritance;
Lines 83-88 Link Here
83	import org.eclipse.jpt.utility.internal.StringTools;	85	import org.eclipse.jpt.utility.internal.StringTools;
84	import org.eclipse.jpt.utility.internal.iterables.CompositeIterable;	86	import org.eclipse.jpt.utility.internal.iterables.CompositeIterable;
85	import org.eclipse.jpt.utility.internal.iterables.FilteringIterable;	87	import org.eclipse.jpt.utility.internal.iterables.FilteringIterable;
		88	import org.eclipse.jpt.utility.internal.iterables.SubIterableWrapper;
86	import org.eclipse.jpt.utility.internal.iterables.TransformationIterable;	89	import org.eclipse.jpt.utility.internal.iterables.TransformationIterable;
87	import org.eclipse.jpt.utility.internal.iterators.CloneIterator;	90	import org.eclipse.jpt.utility.internal.iterators.CloneIterator;
88	import org.eclipse.jpt.utility.internal.iterators.CloneListIterator;	91	import org.eclipse.jpt.utility.internal.iterators.CloneListIterator;
Lines 1729-1747 Link Here
1729	return this.resourceTypeMapping.getInheritanceStrategyTextRange();	1732	return this.resourceTypeMapping.getInheritanceStrategyTextRange();
1730	}	1733	}
1731		1734
1732	class AssociationOverrideContainerOwner implements OrmAssociationOverrideContainer.Owner {	1735	class AssociationOverrideContainerOwner
		1736	implements OrmAssociationOverrideContainer.Owner
		1737	{
		1738	public OrmTypeMapping getTypeMapping() {
		1739	return AbstractOrmEntity.this.getTypeMapping();
		1740	}
		1741
1733	public TypeMapping getOverridableTypeMapping() {	1742	public TypeMapping getOverridableTypeMapping() {
1734	return AbstractOrmEntity.this.getOverridableTypeMapping();	1743	return AbstractOrmEntity.this.getOverridableTypeMapping();
1735	}	1744	}
1736		1745
1737	public OrmTypeMapping getTypeMapping() {	1746	public Iterator<String> allOverridableNames() {
1738	return AbstractOrmEntity.this.getTypeMapping();	1747	TypeMapping typeMapping = getOverridableTypeMapping();
		1748	return (typeMapping == null) ?
		1749	EmptyIterator.<String>instance()
		1750	: typeMapping.allOverridableAssociationNames();
1739	}	1751	}
1740		1752
1741	public EList<XmlAssociationOverride> getResourceAssociationOverrides() {	1753	public EList<XmlAssociationOverride> getResourceAssociationOverrides() {
1742	return AbstractOrmEntity.this.resourceTypeMapping.getAssociationOverrides();	1754	return AbstractOrmEntity.this.resourceTypeMapping.getAssociationOverrides();
1743	}	1755	}
1744		1756
1745	public RelationshipReference resolveRelationshipReference(String associationOverrideName) {	1757	public RelationshipReference resolveRelationshipReference(String associationOverrideName) {
1746	if (!isMetadataComplete()) {	1758	if (!isMetadataComplete()) {
1747	JavaPersistentType javaPersistentType = getPersistentType().getJavaPersistentType();	1759	JavaPersistentType javaPersistentType = getPersistentType().getJavaPersistentType();
Lines 1758-1768 Link Here
1758	public boolean tableNameIsInvalid(String tableName) {	1770	public boolean tableNameIsInvalid(String tableName) {
1759	return AbstractOrmEntity.this.tableNameIsInvalid(tableName);	1771	return AbstractOrmEntity.this.tableNameIsInvalid(tableName);
1760	}	1772	}
1761		1773
1762	public Iterator<String> candidateTableNames() {	1774	public Iterator<String> candidateTableNames() {
1763	return AbstractOrmEntity.this.associatedTableNamesIncludingInherited();	1775	return AbstractOrmEntity.this.associatedTableNamesIncludingInherited();
1764	}	1776	}
1765		1777
1766	public org.eclipse.jpt.db.Table getDbTable(String tableName) {	1778	public org.eclipse.jpt.db.Table getDbTable(String tableName) {
1767	return AbstractOrmEntity.this.getDbTable(tableName);	1779	return AbstractOrmEntity.this.getDbTable(tableName);
1768	}	1780	}
Lines 1770-1776 Link Here
1770	public String getDefaultTableName() {	1782	public String getDefaultTableName() {
1771	return AbstractOrmEntity.this.getPrimaryTableName();	1783	return AbstractOrmEntity.this.getPrimaryTableName();
1772	}	1784	}
1773		1785
1774	public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {	1786	public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {
1775	if (override.isVirtual()) {	1787	if (override.isVirtual()) {
1776	return this.buildVirtualOverrideColumnTableNotValidMessage(override.getName(), column, textRange);	1788	return this.buildVirtualOverrideColumnTableNotValidMessage(override.getName(), column, textRange);
Lines 1786-1792 Link Here
1786	textRange	1798	textRange
1787	);	1799	);
1788	}	1800	}
1789		1801
1790	protected IMessage buildVirtualOverrideColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {	1802	protected IMessage buildVirtualOverrideColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
1791	return DefaultJpaValidationMessages.buildMessage(	1803	return DefaultJpaValidationMessages.buildMessage(
1792	IMessage.HIGH_SEVERITY,	1804	IMessage.HIGH_SEVERITY,
Lines 1800-1806 Link Here
1800	textRange	1812	textRange
1801	);	1813	);
1802	}	1814	}
1803		1815
1804	public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {	1816	public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {
1805	if (override.isVirtual()) {	1817	if (override.isVirtual()) {
1806	return this.buildVirtualColumnUnresolvedNameMessage(override.getName(), column, textRange);	1818	return this.buildVirtualColumnUnresolvedNameMessage(override.getName(), column, textRange);
Lines 1813-1819 Link Here
1813	textRange	1825	textRange
1814	);	1826	);
1815	}	1827	}
1816		1828
1817	protected IMessage buildVirtualColumnUnresolvedNameMessage(String overrideName, NamedColumn column, TextRange textRange) {	1829	protected IMessage buildVirtualColumnUnresolvedNameMessage(String overrideName, NamedColumn column, TextRange textRange) {
1818	return DefaultJpaValidationMessages.buildMessage(	1830	return DefaultJpaValidationMessages.buildMessage(
1819	IMessage.HIGH_SEVERITY,	1831	IMessage.HIGH_SEVERITY,
Lines 1823-1830 Link Here
1823	textRange	1835	textRange
1824	);	1836	);
1825	}	1837	}
1826		1838
1827
1828	public IMessage buildColumnUnresolvedReferencedColumnNameMessage(AssociationOverride override, BaseJoinColumn column, TextRange textRange) {	1839	public IMessage buildColumnUnresolvedReferencedColumnNameMessage(AssociationOverride override, BaseJoinColumn column, TextRange textRange) {
1829	if (override.isVirtual()) {	1840	if (override.isVirtual()) {
1830	return this.buildVirtualColumnUnresolvedReferencedColumnNameMessage(override.getName(), column, textRange);	1841	return this.buildVirtualColumnUnresolvedReferencedColumnNameMessage(override.getName(), column, textRange);
Lines 1860-1866 Link Here
1860	textRange	1871	textRange
1861	);	1872	);
1862	}	1873	}
1863		1874
1864	protected IMessage buildVirtualUnspecifiedNameMultipleJoinColumnsMessage(String overrideName, BaseJoinColumn column, TextRange textRange) {	1875	protected IMessage buildVirtualUnspecifiedNameMultipleJoinColumnsMessage(String overrideName, BaseJoinColumn column, TextRange textRange) {
1865	return DefaultJpaValidationMessages.buildMessage(	1876	return DefaultJpaValidationMessages.buildMessage(
1866	IMessage.HIGH_SEVERITY,	1877	IMessage.HIGH_SEVERITY,
Lines 1870-1876 Link Here
1870	textRange	1881	textRange
1871	);	1882	);
1872	}	1883	}
1873		1884
1874	public IMessage buildUnspecifiedReferencedColumnNameMultipleJoinColumnsMessage(AssociationOverride override, BaseJoinColumn column, TextRange textRange) {	1885	public IMessage buildUnspecifiedReferencedColumnNameMultipleJoinColumnsMessage(AssociationOverride override, BaseJoinColumn column, TextRange textRange) {
1875	if (override.isVirtual()) {	1886	if (override.isVirtual()) {
1876	return this.buildVirtualUnspecifiedReferencedColumnNameMultipleJoinColumnsMessage(override.getName(), column, textRange);	1887	return this.buildVirtualUnspecifiedReferencedColumnNameMultipleJoinColumnsMessage(override.getName(), column, textRange);
Lines 1883-1889 Link Here
1883	textRange	1894	textRange
1884	);	1895	);
1885	}	1896	}
1886		1897
1887	protected IMessage buildVirtualUnspecifiedReferencedColumnNameMultipleJoinColumnsMessage(String overrideName, BaseJoinColumn column, TextRange textRange) {	1898	protected IMessage buildVirtualUnspecifiedReferencedColumnNameMultipleJoinColumnsMessage(String overrideName, BaseJoinColumn column, TextRange textRange) {
1888	return DefaultJpaValidationMessages.buildMessage(	1899	return DefaultJpaValidationMessages.buildMessage(
1889	IMessage.HIGH_SEVERITY,	1900	IMessage.HIGH_SEVERITY,
Lines 1899-1919 Link Here
1899	}	1910	}
1900	}	1911	}
1901		1912
		1913
1902	//******** OrmAttributeOverrideContainer.Owner implementation *******	1914	//******** OrmAttributeOverrideContainer.Owner implementation *******
1903		1915
1904	class AttributeOverrideContainerOwner implements OrmAttributeOverrideContainer.Owner {	1916	class AttributeOverrideContainerOwner
		1917	implements OrmAttributeOverrideContainer.Owner
		1918	{
		1919	public OrmTypeMapping getTypeMapping() {
		1920	return AbstractOrmEntity.this.getTypeMapping();
		1921	}
		1922
1905	public TypeMapping getOverridableTypeMapping() {	1923	public TypeMapping getOverridableTypeMapping() {
1906	return AbstractOrmEntity.this.getOverridableTypeMapping();	1924	return AbstractOrmEntity.this.getOverridableTypeMapping();
1907	}	1925	}
1908		1926
1909	public OrmTypeMapping getTypeMapping() {	1927	public Iterator<String> allOverridableNames() {
1910	return AbstractOrmEntity.this.getTypeMapping();	1928	TypeMapping typeMapping = getOverridableTypeMapping();
		1929	return (typeMapping == null) ?
		1930	EmptyIterator.<String>instance()
		1931	: allOverridableAttributeNames_(typeMapping);
1911	}	1932	}
1912		1933
		1934	/* assumes the type mapping is not null */
		1935	protected Iterator allOverridableAttributeNames_(TypeMapping typeMapping) {
		1936	final Collection mappedByRelationshipAttributes = CollectionTools.collection(
		1937	new TransformationIterator<SingleRelationshipMapping2_0, String>(getMapsIdRelationships()) {
		1938	@Override
		1939	protected String transform(SingleRelationshipMapping2_0 next) {
		1940	return next.getDerivedIdentity().getMapsIdDerivedIdentityStrategy().getValue();
		1941	}
		1942	});
		1943	return new FilteringIterator<String>(typeMapping.allOverridableAttributeNames()) {
		1944	@Override
		1945	protected boolean accept(String o) {
		1946	return ! mappedByRelationshipAttributes.contains(o);
		1947	}
		1948	};
		1949	}
		1950
		1951	protected Iterable<SingleRelationshipMapping2_0> getMapsIdRelationships() {
		1952	return new FilteringIterable<SingleRelationshipMapping2_0>(
		1953	new SubIterableWrapper<AttributeMapping, SingleRelationshipMapping2_0>(
		1954	new CompositeIterable<AttributeMapping>(
		1955	getTypeMapping().getAllAttributeMappings(MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY),
		1956	getTypeMapping().getAllAttributeMappings(MappingKeys.MANY_TO_ONE_ATTRIBUTE_MAPPING_KEY)))) {
		1957	@Override
		1958	protected boolean accept(SingleRelationshipMapping2_0 o) {
		1959	return o.getDerivedIdentity().usesMapsIdDerivedIdentityStrategy();
		1960	}
		1961	};
		1962	}
		1963
1913	public EList<XmlAttributeOverride> getResourceAttributeOverrides() {	1964	public EList<XmlAttributeOverride> getResourceAttributeOverrides() {
1914	return AbstractOrmEntity.this.resourceTypeMapping.getAttributeOverrides();	1965	return AbstractOrmEntity.this.resourceTypeMapping.getAttributeOverrides();
1915	}	1966	}
1916		1967
1917	public Column resolveOverriddenColumn(String attributeOverrideName) {	1968	public Column resolveOverriddenColumn(String attributeOverrideName) {
1918	if (!isMetadataComplete()) {	1969	if (!isMetadataComplete()) {
1919	JavaPersistentType javaPersistentType = getPersistentType().getJavaPersistentType();	1970	JavaPersistentType javaPersistentType = getPersistentType().getJavaPersistentType();
Lines 1941-1947 Link Here
1941	}	1992	}
1942	return new VirtualXmlColumn(AbstractOrmEntity.this, javaAttributeOverride.getColumn());	1993	return new VirtualXmlColumn(AbstractOrmEntity.this, javaAttributeOverride.getColumn());
1943	}	1994	}
1944		1995
1945	public boolean tableNameIsInvalid(String tableName) {	1996	public boolean tableNameIsInvalid(String tableName) {
1946	return AbstractOrmEntity.this.tableNameIsInvalid(tableName);	1997	return AbstractOrmEntity.this.tableNameIsInvalid(tableName);
1947	}	1998	}
Lines 1949-1955 Link Here
1949	public Iterator<String> candidateTableNames() {	2000	public Iterator<String> candidateTableNames() {
1950	return AbstractOrmEntity.this.associatedTableNamesIncludingInherited();	2001	return AbstractOrmEntity.this.associatedTableNamesIncludingInherited();
1951	}	2002	}
1952		2003
1953	public org.eclipse.jpt.db.Table getDbTable(String tableName) {	2004	public org.eclipse.jpt.db.Table getDbTable(String tableName) {
1954	return AbstractOrmEntity.this.getDbTable(tableName);	2005	return AbstractOrmEntity.this.getDbTable(tableName);
1955	}	2006	}
Lines 1957-1963 Link Here
1957	public String getDefaultTableName() {	2008	public String getDefaultTableName() {
1958	return AbstractOrmEntity.this.getPrimaryTableName();	2009	return AbstractOrmEntity.this.getPrimaryTableName();
1959	}	2010	}
1960		2011
1961	public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {	2012	public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {
1962	if (override.isVirtual()) {	2013	if (override.isVirtual()) {
1963	return this.buildVirtualColumnUnresolvedNameMessage(override.getName(), column, textRange);	2014	return this.buildVirtualColumnUnresolvedNameMessage(override.getName(), column, textRange);
Lines 1970-1976 Link Here
1970	textRange	2021	textRange
1971	);	2022	);
1972	}	2023	}
1973		2024
1974	public IMessage buildVirtualColumnUnresolvedNameMessage(String overrideName, NamedColumn column, TextRange textRange) {	2025	public IMessage buildVirtualColumnUnresolvedNameMessage(String overrideName, NamedColumn column, TextRange textRange) {
1975	return DefaultJpaValidationMessages.buildMessage(	2026	return DefaultJpaValidationMessages.buildMessage(
1976	IMessage.HIGH_SEVERITY,	2027	IMessage.HIGH_SEVERITY,
Lines 1980-1986 Link Here
1980	textRange	2031	textRange
1981	);	2032	);
1982	}	2033	}
1983		2034
1984	public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {	2035	public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {
1985	if (override.isVirtual()) {	2036	if (override.isVirtual()) {
1986	return this.buildVirtualOverrideColumnTableNotValidMessage(override.getName(), column, textRange);	2037	return this.buildVirtualOverrideColumnTableNotValidMessage(override.getName(), column, textRange);
Lines 1996-2002 Link Here
1996	textRange	2047	textRange
1997	);	2048	);
1998	}	2049	}
1999		2050
2000	protected IMessage buildVirtualOverrideColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {	2051	protected IMessage buildVirtualOverrideColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
2001	return DefaultJpaValidationMessages.buildMessage(	2052	return DefaultJpaValidationMessages.buildMessage(
2002	IMessage.HIGH_SEVERITY,	2053	IMessage.HIGH_SEVERITY,
Lines 2015-2020 Link Here
2015	}	2066	}
2016	}	2067	}
2017		2068
		2069
2018	class PrimaryKeyJoinColumnOwner implements OrmBaseJoinColumn.Owner	2070	class PrimaryKeyJoinColumnOwner implements OrmBaseJoinColumn.Owner
2019	{	2071	{
2020	public TypeMapping getTypeMapping() {	2072	public TypeMapping getTypeMapping() {

Lines 13-20 Link Here

(-)src/org/eclipse/jpt/core/context/java/JavaAttributeOverride.java (-5 / +4 lines)
13	import org.eclipse.jpt.core.resource.java.AttributeOverrideAnnotation;	13	import org.eclipse.jpt.core.resource.java.AttributeOverrideAnnotation;
14		14
15	/**	15	/**
16	*
17	*
18	* Provisional API: This interface is part of an interim API that is still	16	* Provisional API: This interface is part of an interim API that is still
19	* under development and expected to change significantly before reaching	17	* under development and expected to change significantly before reaching
20	* stability. It is available at this early stage to solicit feedback from	18	* stability. It is available at this early stage to solicit feedback from
Lines 32-38 Link Here
32	JavaAttributeOverride setVirtual(boolean virtual);	30	JavaAttributeOverride setVirtual(boolean virtual);
33		31
34	AttributeOverrideAnnotation getOverrideAnnotation();	32	AttributeOverrideAnnotation getOverrideAnnotation();
35		33
36	void initialize(AttributeOverrideAnnotation attributeOverride);	34	void initialize(AttributeOverrideAnnotation attributeOverride);
37		35
38	/**	36	/**
Lines 40-47 Link Here
40	* resource model object. see {@link org.eclipse.jpt.core.JpaProject#update()}	38	* resource model object. see {@link org.eclipse.jpt.core.JpaProject#update()}
41	*/	39	*/
42	void update(AttributeOverrideAnnotation attributeOverride);	40	void update(AttributeOverrideAnnotation attributeOverride);
43		41
44	interface Owner extends AttributeOverride.Owner, JavaOverride.Owner	42	interface Owner
		43	extends AttributeOverride.Owner, JavaOverride.Owner
45	{	44	{
46	//nothing yet	45	//nothing yet
47	}	46	}

Lines 1284-1291 Link Here

(-)src/org/eclipse/jpt/core/internal/jpa2/context/java/GenericJavaElementCollectionMapping2_0.java (-35 / +58 lines)
1284		1284
1285	// ******** override container owners ********	1285	// ******** override container owners ********
1286		1286
1287	abstract class OverrideContainerOwner implements JavaOverrideContainer.Owner {	1287	abstract class OverrideContainerOwner
1288		1288	implements JavaOverrideContainer.Owner
		1289	{
1289	public TypeMapping getTypeMapping() {	1290	public TypeMapping getTypeMapping() {
1290	return GenericJavaElementCollectionMapping2_0.this.getTypeMapping();	1291	return GenericJavaElementCollectionMapping2_0.this.getTypeMapping();
1291	}	1292	}
Lines 1297-1303 Link Here
1297	public org.eclipse.jpt.db.Table getDbTable(String tableName) {	1298	public org.eclipse.jpt.db.Table getDbTable(String tableName) {
1298	return GenericJavaElementCollectionMapping2_0.this.getCollectionTable().getDbTable();	1299	return GenericJavaElementCollectionMapping2_0.this.getCollectionTable().getDbTable();
1299	}	1300	}
1300		1301
1301	public java.util.Iterator<String> candidateTableNames() {	1302	public java.util.Iterator<String> candidateTableNames() {
1302	return EmptyIterator.instance();	1303	return EmptyIterator.instance();
1303	}	1304	}
Lines 1314-1339 Link Here
1314	return GenericJavaElementCollectionMapping2_0.this.getValidationTextRange(astRoot);	1315	return GenericJavaElementCollectionMapping2_0.this.getValidationTextRange(astRoot);
1315	}	1316	}
1316	}	1317	}
1317		1318
1318	class ValueAssociationOverrideContainerOwner extends OverrideContainerOwner	1319	class ValueAssociationOverrideContainerOwner
1319	implements JavaAssociationOverrideContainer.Owner {	1320	extends OverrideContainerOwner
1320		1321	implements JavaAssociationOverrideContainer.Owner
		1322	{
1321	public TypeMapping getOverridableTypeMapping() {	1323	public TypeMapping getOverridableTypeMapping() {
1322	return GenericJavaElementCollectionMapping2_0.this.getResolvedTargetEmbeddable();	1324	return GenericJavaElementCollectionMapping2_0.this.getResolvedTargetEmbeddable();
1323	}	1325	}
1324		1326
		1327	public Iterator<String> allOverridableNames() {
		1328	TypeMapping typeMapping = getOverridableTypeMapping();
		1329	return (typeMapping == null) ?
		1330	EmptyIterator.<String>instance()
		1331	: typeMapping.allOverridableAssociationNames();
		1332	}
		1333
1325	public RelationshipReference resolveRelationshipReference(String associationOverrideName) {	1334	public RelationshipReference resolveRelationshipReference(String associationOverrideName) {
1326	return MappingTools.resolveRelationshipReference(getOverridableTypeMapping(), associationOverrideName);	1335	return MappingTools.resolveRelationshipReference(getOverridableTypeMapping(), associationOverrideName);
1327	}	1336	}
1328		1337
1329	public String getPossiblePrefix() {	1338	public String getPossiblePrefix() {
1330	return "value."; //$NON-NLS-1$	1339	return "value."; //$NON-NLS-1$
1331	}	1340	}
1332		1341
1333	public String getWritePrefix() {	1342	public String getWritePrefix() {
1334	return getPersistentAttribute().getJpaContainer().isMap() ? this.getPossiblePrefix() : null;	1343	return getPersistentAttribute().getJpaContainer().isMap() ? this.getPossiblePrefix() : null;
1335	}	1344	}
1336		1345
1337	//return false if the override is prefixed with "key.", these will be part of the MapKeyAttributeOverrideContainer.	1346	//return false if the override is prefixed with "key.", these will be part of the MapKeyAttributeOverrideContainer.
1338	//a prefix of "value." or no prefix at all is relevant. If the type is not a Map then return true since all attribute overrides	1347	//a prefix of "value." or no prefix at all is relevant. If the type is not a Map then return true since all attribute overrides
1339	//need to apply to the value.	1348	//need to apply to the value.
Lines 1343-1349 Link Here
1343	}	1352	}
1344	return !overrideName.startsWith("key."); //$NON-NLS-1$	1353	return !overrideName.startsWith("key."); //$NON-NLS-1$
1345	}	1354	}
1346		1355
1347	public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {	1356	public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {
1348	if (override.isVirtual()) {	1357	if (override.isVirtual()) {
1349	return this.buildVirtualOverrideColumnTableNotValidMessage(override.getName(), column, textRange);	1358	return this.buildVirtualOverrideColumnTableNotValidMessage(override.getName(), column, textRange);
Lines 1359-1365 Link Here
1359	textRange	1368	textRange
1360	);	1369	);
1361	}	1370	}
1362		1371
1363	protected IMessage buildVirtualOverrideColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {	1372	protected IMessage buildVirtualOverrideColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
1364	return DefaultJpaValidationMessages.buildMessage(	1373	return DefaultJpaValidationMessages.buildMessage(
1365	IMessage.HIGH_SEVERITY,	1374	IMessage.HIGH_SEVERITY,
Lines 1396-1402 Link Here
1396	textRange	1405	textRange
1397	);	1406	);
1398	}	1407	}
1399		1408
1400	public IMessage buildColumnUnresolvedReferencedColumnNameMessage(AssociationOverride override, BaseJoinColumn column, TextRange textRange) {	1409	public IMessage buildColumnUnresolvedReferencedColumnNameMessage(AssociationOverride override, BaseJoinColumn column, TextRange textRange) {
1401	if (override.isVirtual()) {	1410	if (override.isVirtual()) {
1402	return this.buildVirtualColumnUnresolvedReferencedColumnNameMessage(override.getName(), column, textRange);	1411	return this.buildVirtualColumnUnresolvedReferencedColumnNameMessage(override.getName(), column, textRange);
Lines 1409-1415 Link Here
1409	textRange	1418	textRange
1410	);	1419	);
1411	}	1420	}
1412		1421
1413	protected IMessage buildVirtualColumnUnresolvedReferencedColumnNameMessage(String overrideName, BaseJoinColumn column, TextRange textRange) {	1422	protected IMessage buildVirtualColumnUnresolvedReferencedColumnNameMessage(String overrideName, BaseJoinColumn column, TextRange textRange) {
1414	return DefaultJpaValidationMessages.buildMessage(	1423	return DefaultJpaValidationMessages.buildMessage(
1415	IMessage.HIGH_SEVERITY,	1424	IMessage.HIGH_SEVERITY,
Lines 1419-1425 Link Here
1419	textRange	1428	textRange
1420	);	1429	);
1421	}	1430	}
1422		1431
1423	public IMessage buildUnspecifiedNameMultipleJoinColumnsMessage(AssociationOverride override, BaseJoinColumn column, TextRange textRange) {	1432	public IMessage buildUnspecifiedNameMultipleJoinColumnsMessage(AssociationOverride override, BaseJoinColumn column, TextRange textRange) {
1424	if (override.isVirtual()) {	1433	if (override.isVirtual()) {
1425	return this.buildVirtualUnspecifiedNameMultipleJoinColumnsMessage(override.getName(), column, textRange);	1434	return this.buildVirtualUnspecifiedNameMultipleJoinColumnsMessage(override.getName(), column, textRange);
Lines 1432-1438 Link Here
1432	textRange	1441	textRange
1433	);	1442	);
1434	}	1443	}
1435		1444
1436	protected IMessage buildVirtualUnspecifiedNameMultipleJoinColumnsMessage(String overrideName, BaseJoinColumn column, TextRange textRange) {	1445	protected IMessage buildVirtualUnspecifiedNameMultipleJoinColumnsMessage(String overrideName, BaseJoinColumn column, TextRange textRange) {
1437	return DefaultJpaValidationMessages.buildMessage(	1446	return DefaultJpaValidationMessages.buildMessage(
1438	IMessage.HIGH_SEVERITY,	1447	IMessage.HIGH_SEVERITY,
Lines 1455-1461 Link Here
1455	textRange	1464	textRange
1456	);	1465	);
1457	}	1466	}
1458		1467
1459	protected IMessage buildVirtualUnspecifiedReferencedColumnNameMultipleJoinColumnsMessage(String overrideName, BaseJoinColumn column, TextRange textRange) {	1468	protected IMessage buildVirtualUnspecifiedReferencedColumnNameMultipleJoinColumnsMessage(String overrideName, BaseJoinColumn column, TextRange textRange) {
1460	return DefaultJpaValidationMessages.buildMessage(	1469	return DefaultJpaValidationMessages.buildMessage(
1461	IMessage.HIGH_SEVERITY,	1470	IMessage.HIGH_SEVERITY,
Lines 1477-1494 Link Here
1477	return GenericJavaElementCollectionMapping2_0.this.getResolvedTargetEmbeddable();	1486	return GenericJavaElementCollectionMapping2_0.this.getResolvedTargetEmbeddable();
1478	}	1487	}
1479		1488
		1489	public Iterator<String> allOverridableNames() {
		1490	TypeMapping typeMapping = getOverridableTypeMapping();
		1491	return (typeMapping == null) ?
		1492	EmptyIterator.<String>instance()
		1493	: typeMapping.allOverridableAttributeNames();
		1494	}
		1495
1480	public Column resolveOverriddenColumn(String attributeOverrideName) {	1496	public Column resolveOverriddenColumn(String attributeOverrideName) {
1481	return MappingTools.resolveOverridenColumn(getOverridableTypeMapping(), attributeOverrideName);	1497	return MappingTools.resolveOverridenColumn(getOverridableTypeMapping(), attributeOverrideName);
1482	}	1498	}
1483		1499
1484	public String getPossiblePrefix() {	1500	public String getPossiblePrefix() {
1485	return "value."; //$NON-NLS-1$	1501	return "value."; //$NON-NLS-1$
1486	}	1502	}
1487		1503
1488	public String getWritePrefix() {	1504	public String getWritePrefix() {
1489	return getPersistentAttribute().getJpaContainer().isMap() ? this.getPossiblePrefix() : null;	1505	return getPersistentAttribute().getJpaContainer().isMap() ? this.getPossiblePrefix() : null;
1490	}	1506	}
1491		1507
1492	//return false if the override is prefixed with "key.", these will be part of the MapKeyAttributeOverrideContainer.	1508	//return false if the override is prefixed with "key.", these will be part of the MapKeyAttributeOverrideContainer.
1493	//a prefix of "value." or no prefix at all is relevant. If the type is not a Map then return true since all attribute overrides	1509	//a prefix of "value." or no prefix at all is relevant. If the type is not a Map then return true since all attribute overrides
1494	//need to apply to the value.	1510	//need to apply to the value.
Lines 1498-1504 Link Here
1498	}	1514	}
1499	return !overrideName.startsWith("key."); //$NON-NLS-1$	1515	return !overrideName.startsWith("key."); //$NON-NLS-1$
1500	}	1516	}
1501		1517
1502	public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {	1518	public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {
1503	if (override.isVirtual()) {	1519	if (override.isVirtual()) {
1504	return this.buildVirtualColumnUnresolvedNameMessage(override.getName(), column, textRange);	1520	return this.buildVirtualColumnUnresolvedNameMessage(override.getName(), column, textRange);
Lines 1521-1527 Link Here
1521	textRange	1537	textRange
1522	);	1538	);
1523	}	1539	}
1524		1540
1525	public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {	1541	public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {
1526	if (override.isVirtual()) {	1542	if (override.isVirtual()) {
1527	return this.buildVirtualColumnTableNotValidMessage(override.getName(), column, textRange);	1543	return this.buildVirtualColumnTableNotValidMessage(override.getName(), column, textRange);
Lines 1537-1543 Link Here
1537	textRange	1553	textRange
1538	);	1554	);
1539	}	1555	}
1540		1556
1541	protected IMessage buildVirtualColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {	1557	protected IMessage buildVirtualColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
1542	return DefaultJpaValidationMessages.buildMessage(	1558	return DefaultJpaValidationMessages.buildMessage(
1543	IMessage.HIGH_SEVERITY,	1559	IMessage.HIGH_SEVERITY,
Lines 1553-1571 Link Here
1553	}	1569	}
1554	}	1570	}
1555		1571
		1572
1556	class MapKeyAttributeOverrideContainerOwner	1573	class MapKeyAttributeOverrideContainerOwner
1557	extends OverrideContainerOwner	1574	extends OverrideContainerOwner
1558	implements JavaAttributeOverrideContainer.Owner	1575	implements JavaAttributeOverrideContainer.Owner
1559	{	1576	{
1560		1577	public TypeMapping getOverridableTypeMapping() {
		1578	return GenericJavaElementCollectionMapping2_0.this.getResolvedMapKeyEmbeddable();
		1579	}
		1580
		1581	public Iterator<String> allOverridableNames() {
		1582	TypeMapping typeMapping = getOverridableTypeMapping();
		1583	return (typeMapping == null) ?
		1584	EmptyIterator.<String>instance()
		1585	: typeMapping.allOverridableAttributeNames();
		1586	}
		1587
1561	public String getPossiblePrefix() {	1588	public String getPossiblePrefix() {
1562	return "key."; //$NON-NLS-1$	1589	return "key."; //$NON-NLS-1$
1563	}	1590	}
1564		1591
1565	public String getWritePrefix() {	1592	public String getWritePrefix() {
1566	return this.getPossiblePrefix();	1593	return this.getPossiblePrefix();
1567	}	1594	}
1568		1595
1569	//the only relevant overrides are those that start with "key.", no prefix will be a value attribute override	1596	//the only relevant overrides are those that start with "key.", no prefix will be a value attribute override
1570	public boolean isRelevant(String overrideName) {	1597	public boolean isRelevant(String overrideName) {
1571	if (getValueType() != Type.EMBEDDABLE_TYPE) {	1598	if (getValueType() != Type.EMBEDDABLE_TYPE) {
Lines 1573-1587 Link Here
1573	}	1600	}
1574	return overrideName.startsWith("key."); //$NON-NLS-1$	1601	return overrideName.startsWith("key."); //$NON-NLS-1$
1575	}	1602	}
1576		1603
1577	public TypeMapping getOverridableTypeMapping() {
1578	return GenericJavaElementCollectionMapping2_0.this.getResolvedMapKeyEmbeddable();
1579	}
1580
1581	public Column resolveOverriddenColumn(String attributeOverrideName) {	1604	public Column resolveOverriddenColumn(String attributeOverrideName) {
1582	return MappingTools.resolveOverridenColumn(getOverridableTypeMapping(), attributeOverrideName);	1605	return MappingTools.resolveOverridenColumn(getOverridableTypeMapping(), attributeOverrideName);
1583	}	1606	}
1584		1607
1585	public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {	1608	public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {
1586	if (override.isVirtual()) {	1609	if (override.isVirtual()) {
1587	return this.buildVirtualColumnUnresolvedNameMessage(override.getName(), column, textRange);	1610	return this.buildVirtualColumnUnresolvedNameMessage(override.getName(), column, textRange);
Lines 1604-1610 Link Here
1604	textRange	1627	textRange
1605	);	1628	);
1606	}	1629	}
1607		1630
1608	public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {	1631	public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {
1609	if (override.isVirtual()) {	1632	if (override.isVirtual()) {
1610	return this.buildVirtualColumnTableNotValidMessage(override.getName(), column, textRange);	1633	return this.buildVirtualColumnTableNotValidMessage(override.getName(), column, textRange);
Lines 1620-1626 Link Here
1620	textRange	1643	textRange
1621	);	1644	);
1622	}	1645	}
1623		1646
1624	protected IMessage buildVirtualColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {	1647	protected IMessage buildVirtualColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
1625	return DefaultJpaValidationMessages.buildMessage(	1648	return DefaultJpaValidationMessages.buildMessage(
1626	IMessage.HIGH_SEVERITY,	1649	IMessage.HIGH_SEVERITY,

Lines 10-17 Link Here

(-)src/org/eclipse/jpt/core/context/AttributeOverride.java (-4 / +3 lines)
10	package org.eclipse.jpt.core.context;	10	package org.eclipse.jpt.core.context;
11		11
12	/**	12	/**
13	*
14	*
15	* Provisional API: This interface is part of an interim API that is still	13	* Provisional API: This interface is part of an interim API that is still
16	* under development and expected to change significantly before reaching	14	* under development and expected to change significantly before reaching
17	* stability. It is available at this early stage to solicit feedback from	15	* stability. It is available at this early stage to solicit feedback from
Lines 21-27 Link Here
21	* @version 2.3	19	* @version 2.3
22	* @since 2.0	20	* @since 2.0
23	*/	21	*/
24	public interface AttributeOverride extends BaseOverride, Column.Owner	22	public interface AttributeOverride
		23	extends BaseOverride, Column.Owner
25	{	24	{
26	Column getColumn();	25	Column getColumn();
27		26
Lines 36-39 Link Here
36	*/	35	*/
37	Column resolveOverriddenColumn(String attributeName);	36	Column resolveOverriddenColumn(String attributeName);
38	}	37	}
39	}	38	}

Lines 210-220 Link Here

(-)src/org/eclipse/jpt/core/resource/orm/AbstractXmlEmbedded.java (-4 / +4 lines)
210	}	210	}
211	return super.eDerivedStructuralFeatureID(baseFeatureID, baseClass);	211	return super.eDerivedStructuralFeatureID(baseFeatureID, baseClass);
212	}	212	}
213		213
		214
214	// ******** translators ********	215	// ******** translators ********
215		216
216	protected static Translator buildAttributeOverrideTranslator() {	217	protected static Translator buildAttributeOverrideTranslator() {
217	return XmlAttributeOverride.buildTranslator(JPA.ATTRIBUTE_OVERRIDE, OrmPackage.eINSTANCE.getXmlAttributeOverrideContainer_AttributeOverrides());	218	return XmlAttributeOverride.buildTranslator(JPA.ATTRIBUTE_OVERRIDE, OrmPackage.eINSTANCE.getXmlAttributeOverrideContainer_AttributeOverrides());
218	}	219	}
219		220	}
220	} // BaseXmlEmbedded

Lines 234-245 Link Here

(-)src/org/eclipse/jpt/core/resource/orm/XmlEmbedded.java (-2 / +3 lines)
234	return MappingKeys.EMBEDDED_ATTRIBUTE_MAPPING_KEY;	234	return MappingKeys.EMBEDDED_ATTRIBUTE_MAPPING_KEY;
235	}	235	}
236		236
		237
237	// ******** translators ********	238	// ******** translators ********
238		239
239	public static Translator buildTranslator(String elementName, EStructuralFeature structuralFeature) {	240	public static Translator buildTranslator(String elementName, EStructuralFeature structuralFeature) {
240	return new SimpleTranslator(elementName, structuralFeature, buildTranslatorChildren());	241	return new SimpleTranslator(elementName, structuralFeature, buildTranslatorChildren());
241	}	242	}
242		243
243	private static Translator[] buildTranslatorChildren() {	244	private static Translator[] buildTranslatorChildren() {
244	return new Translator[] {	245	return new Translator[] {
245	buildNameTranslator(),	246	buildNameTranslator(),

Added Link Here

(-)src/org/eclipse/jpt/core/jpa2/context/IdMapping2_0.java (+38 lines)
1	/*******************************************************************************
2	* Copyright (c) 2010 Oracle.
3	* All rights reserved. This program and the accompanying materials are
4	* made available under the terms of the Eclipse Public License v1.0 which
5	* accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Oracle - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.jpt.core.jpa2.context;
12
13	import org.eclipse.jpt.core.context.IdMapping;
14
15	/**
16	* Provisional API: This interface is part of an interim API that is still
17	* under development and expected to change significantly before reaching
18	* stability. It is available at this early stage to solicit feedback from
19	* pioneering adopters on the understanding that any code that uses this API
20	* will almost certainly be broken (repeatedly) as the API evolves.
21	*
22	* @version 2.3
23	* @since 2.3
24	*/
25	public interface IdMapping2_0
26	extends IdMapping
27	{
28	/**
29	* Property string associated with changes to the mapped by relationship
30	*/
31	final String MAPPED_BY_RELATIONSHIP_PROPERTY = "mappedByRelationship";
32
33	/**
34	* Return whether this id is mapped by a relationship (i.e. a relationship maps this id)
35	* N.B. - This might be several relationships (erroneously, of course)
36	*/
37	boolean isMappedByRelationship();
38	}