jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaEmbeddedMapping.java - dali/webtools.dali - Git at Google

 /*******************************************************************************
  * Copyright (c) 2007, 2011 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.jpa.core.internal.jpa1.context.java;

 import java.util.List;
 import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.common.core.resource.java.JavaResourceAttribute;
 import org.eclipse.jpt.common.core.utility.TextRange;
 import org.eclipse.jpt.common.utility.Filter;
 import org.eclipse.jpt.common.utility.internal.iterables.CompositeIterable;
 import org.eclipse.jpt.common.utility.internal.iterables.EmptyIterable;
 import org.eclipse.jpt.jpa.core.MappingKeys;
 import org.eclipse.jpt.jpa.core.context.AssociationOverride;
 import org.eclipse.jpt.jpa.core.context.AssociationOverrideContainer;
 import org.eclipse.jpt.jpa.core.context.AttributeMapping;
 import org.eclipse.jpt.jpa.core.context.OverrideContainer;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyAssociationOverride;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseColumn;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumn;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinTable;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyOverride;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyTable;
 import org.eclipse.jpt.jpa.core.context.Relationship;
 import org.eclipse.jpt.jpa.core.context.TypeMapping;
 import org.eclipse.jpt.jpa.core.context.java.JavaAssociationOverrideContainer;
 import org.eclipse.jpt.jpa.core.context.java.JavaAttributeOverrideContainer;
 import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute;
 import org.eclipse.jpt.jpa.core.internal.context.AttributeMappingTools;
 import org.eclipse.jpt.jpa.core.internal.context.BaseColumnTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.JoinColumnTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
 import org.eclipse.jpt.jpa.core.internal.context.MappingTools;
 import org.eclipse.jpt.jpa.core.internal.context.OverrideTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.TableTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaBaseEmbeddedMapping;
 import org.eclipse.jpt.jpa.core.internal.jpa1.context.AssociationOverrideInverseJoinColumnValidator;
 import org.eclipse.jpt.jpa.core.internal.jpa1.context.AssociationOverrideJoinColumnValidator;
 import org.eclipse.jpt.jpa.core.internal.jpa1.context.AssociationOverrideJoinTableValidator;
 import org.eclipse.jpt.jpa.core.internal.jpa1.context.AssociationOverrideValidator;
 import org.eclipse.jpt.jpa.core.internal.jpa1.context.EmbeddableOverrideDescriptionProvider;
 import org.eclipse.jpt.jpa.core.internal.jpa1.context.EntityTableDescriptionProvider;
 import org.eclipse.jpt.jpa.core.internal.jpa1.context.JoinTableTableDescriptionProvider;
 import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaAssociationOverrideContainer2_0;
 import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaEmbeddedMapping2_0;
 import org.eclipse.jpt.jpa.core.resource.java.EmbeddedAnnotation;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 import org.eclipse.wst.validation.internal.provisional.core.IReporter;

 /**
  * Java embedded mapping
  */
 public class GenericJavaEmbeddedMapping
 	extends AbstractJavaBaseEmbeddedMapping<EmbeddedAnnotation>
 	implements JavaEmbeddedMapping2_0
 {
 	protected final JavaAssociationOverrideContainer associationOverrideContainer;


 	public GenericJavaEmbeddedMapping(JavaPersistentAttribute parent) {
 		super(parent);
 		this.associationOverrideContainer = this.buildAssociationOverrideContainer();
 	}


 	// ********** synchronize/update **********

 	@Override
 	public void synchronizeWithResourceModel() {
 		super.synchronizeWithResourceModel();
 		this.associationOverrideContainer.synchronizeWithResourceModel();
 	}

 	@Override
 	public void update() {
 		super.update();
 		this.associationOverrideContainer.update();
 	}


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

 	protected JavaAssociationOverrideContainer buildAssociationOverrideContainer() {
 		return this.isJpa2_0Compatible() ?
 				this.getJpaFactory2_0().buildJavaAssociationOverrideContainer(this, this.buildAssociationOverrideContainerOwner()) :
 				new GenericJavaAssociationOverrideContainer(this, null);
 	}

 	public JavaAssociationOverrideContainer getAssociationOverrideContainer() {
 		return this.associationOverrideContainer;
 	}

 	protected JavaAssociationOverrideContainer.Owner buildAssociationOverrideContainerOwner() {
 		return new AssociationOverrideContainerOwner();
 	}


 	// ********** embedded mappings **********

 	/**
 	 * This is only to build the choices for a "mapped by" setting in a
 	 * relationship mapping. JPA 2.0 does not support relationship mappings
 	 * in an embedded ID class; so we only put this logic here.
 	 */
 	@Override
 	@SuppressWarnings("unchecked")
 	public Iterable<String> getAllMappingNames() {
 		return this.isJpa2_0Compatible() ?
 				new CompositeIterable<String>(super.getAllMappingNames(), this.getAllEmbeddableAttributeMappingNames()) :
 				super.getAllMappingNames();
 	}

 	protected Iterable<String> getAllEmbeddableAttributeMappingNames() {
 		return this.getQualifiedEmbeddableOverridableMappingNames(AttributeMappingTools.ALL_MAPPING_NAMES_TRANSFORMER);
 	}

 	@Override
 	public AttributeMapping resolveAttributeMapping(String attributeName) {
 		AttributeMapping resolvedMapping = super.resolveAttributeMapping(attributeName);
 		if (resolvedMapping != null) {
 			return resolvedMapping;
 		}
 		return this.isJpa2_0Compatible() ? this.resolveAttributeMapping_(attributeName) : null;
 	}

 	protected AttributeMapping resolveAttributeMapping_(String attributeName) {
 		attributeName = this.unqualify(attributeName);
 		if (attributeName == null) {
 			return null;
 		}
 		// recurse into the embeddable mappings
 		for (AttributeMapping mapping : this.getEmbeddableAttributeMappings()) {
 			AttributeMapping resolvedMapping = mapping.resolveAttributeMapping(attributeName);
 			if (resolvedMapping != null) {
 				return resolvedMapping;
 			}
 		}
 		return null;
 	}


 	// ********** misc **********

 	public String getKey() {
 		return MappingKeys.EMBEDDED_ATTRIBUTE_MAPPING_KEY;
 	}

 	@Override
 	protected String getAnnotationName() {
 		return EmbeddedAnnotation.ANNOTATION_NAME;
 	}

 	@Override
 	public Relationship resolveOverriddenRelationship(String attributeName) {
 		return this.isJpa2_0Compatible() ? this.resolveOverriddenRelationship_(attributeName) : null;
 	}

 	protected Relationship resolveOverriddenRelationship_(String attributeName) {
 		attributeName = this.unqualify(attributeName);
 		if (attributeName == null) {
 			return null;
 		}
 		AssociationOverride override = this.associationOverrideContainer.getSpecifiedOverrideNamed(attributeName);
 		// recurse into the target embeddable if necessary
 		return (override != null) ? override.getRelationship() : this.resolveOverriddenRelationshipInTargetEmbeddable(attributeName);
 	}

 	protected Relationship resolveOverriddenRelationshipInTargetEmbeddable(String attributeName) {
 		return (this.targetEmbeddable == null) ? null : this.targetEmbeddable.resolveOverriddenRelationship(attributeName);
 	}

 	@Override
 	protected JavaAttributeOverrideContainer.Owner buildAttributeOverrideContainerOwner() {
 		return new AttributeOverrideContainerOwner();
 	}


 	// ********** Java completion proposals **********

 	@Override
 	public Iterable<String> getJavaCompletionProposals(int pos, Filter<String> filter, CompilationUnit astRoot) {
 		Iterable<String> result = super.getJavaCompletionProposals(pos, filter, astRoot);
 		if (result != null) {
 			return result;
 		}

 		result = this.associationOverrideContainer.getJavaCompletionProposals(pos, filter, astRoot);
 		if (result != null) {
 			return result;
 		}

 		return null;
 	}


 	// ********** validation **********

 	@Override
 	protected void validateOverrides(List<IMessage> messages, IReporter reporter, CompilationUnit astRoot) {
 		super.validateOverrides(messages, reporter, astRoot);
 		this.associationOverrideContainer.validate(messages, reporter, astRoot);
 	}


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

 	protected class AttributeOverrideContainerOwner
 		extends AbstractJavaBaseEmbeddedMapping<EmbeddedAnnotation>.AttributeOverrideContainerOwner
 	{
 		// nothing yet
 	}


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

 	protected class AssociationOverrideContainerOwner
 		implements JavaAssociationOverrideContainer2_0.Owner
 	{
 		public JavaResourceAttribute getResourceMember() {
 			return GenericJavaEmbeddedMapping.this.getResourceAttribute();
 		}

 		public TypeMapping getTypeMapping() {
 			return GenericJavaEmbeddedMapping.this.getTypeMapping();
 		}

 		public TypeMapping getOverridableTypeMapping() {
 			return GenericJavaEmbeddedMapping.this.getTargetEmbeddable();
 		}

 		public Iterable<String> getAllOverridableNames() {
 			TypeMapping typeMapping = this.getOverridableTypeMapping();
 			return (typeMapping != null) ? typeMapping.getAllOverridableAssociationNames() : EmptyIterable.<String>instance();
 		}

 		public Relationship resolveOverriddenRelationship(String attributeName) {
 			return MappingTools.resolveOverriddenRelationship(this.getOverridableTypeMapping(), attributeName);
 		}

 		public boolean tableNameIsInvalid(String tableName) {
 			return this.getTypeMapping().tableNameIsInvalid(tableName);
 		}

 		public Iterable<String> getCandidateTableNames() {
 			return this.getTypeMapping().getAllAssociatedTableNames();
 		}

 		public org.eclipse.jpt.jpa.db.Table resolveDbTable(String tableName) {
 			return this.getTypeMapping().resolveDbTable(tableName);
 		}

 		public String getDefaultTableName() {
 			return this.getTypeMapping().getPrimaryTableName();
 		}

 		public String getPossiblePrefix() {
 			return null;
 		}

 		public String getWritePrefix() {
 			return null;
 		}

 		// no maps, so all overrides are relevant
 		public boolean isRelevant(String overrideName) {
 			return true;
 		}

 		public TextRange getValidationTextRange(CompilationUnit astRoot) {
 			return GenericJavaEmbeddedMapping.this.getValidationTextRange(astRoot);
 		}

 		public JptValidator buildOverrideValidator(ReadOnlyOverride override, OverrideContainer container, OverrideTextRangeResolver textRangeResolver) {
 			return new AssociationOverrideValidator(this.getPersistentAttribute(), (ReadOnlyAssociationOverride) override, (AssociationOverrideContainer) container, textRangeResolver, new EmbeddableOverrideDescriptionProvider());
 		}

 		public JptValidator buildColumnValidator(ReadOnlyOverride override, ReadOnlyBaseColumn column, ReadOnlyBaseColumn.Owner owner, BaseColumnTextRangeResolver textRangeResolver) {
 			return new AssociationOverrideJoinColumnValidator(this.getPersistentAttribute(), (ReadOnlyAssociationOverride) override, (ReadOnlyJoinColumn) column, (ReadOnlyJoinColumn.Owner) owner, (JoinColumnTextRangeResolver) textRangeResolver, new EntityTableDescriptionProvider());
 		}

 		public JptValidator buildJoinTableJoinColumnValidator(ReadOnlyAssociationOverride override, ReadOnlyJoinColumn column, ReadOnlyJoinColumn.Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
 			return new AssociationOverrideJoinColumnValidator(this.getPersistentAttribute(), override, column, owner, textRangeResolver, new JoinTableTableDescriptionProvider());
 		}

 		public JptValidator buildJoinTableInverseJoinColumnValidator(ReadOnlyAssociationOverride override, ReadOnlyJoinColumn column, ReadOnlyJoinColumn.Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
 			return new AssociationOverrideInverseJoinColumnValidator(this.getPersistentAttribute(), override, column, owner, textRangeResolver, new JoinTableTableDescriptionProvider());
 		}

 		public JptValidator buildJoinTableValidator(ReadOnlyAssociationOverride override, ReadOnlyTable table, TableTextRangeResolver textRangeResolver) {
 			return new AssociationOverrideJoinTableValidator(this.getPersistentAttribute(), override, (ReadOnlyJoinTable) table, textRangeResolver);
 		}

 		protected JavaPersistentAttribute getPersistentAttribute() {
 			return GenericJavaEmbeddedMapping.this.getPersistentAttribute();
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2007, 2011 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.jpa.core.internal.jpa1.context.java;

	import java.util.List;
	import org.eclipse.jdt.core.dom.CompilationUnit;
	import org.eclipse.jpt.common.core.resource.java.JavaResourceAttribute;
	import org.eclipse.jpt.common.core.utility.TextRange;
	import org.eclipse.jpt.common.utility.Filter;
	import org.eclipse.jpt.common.utility.internal.iterables.CompositeIterable;
	import org.eclipse.jpt.common.utility.internal.iterables.EmptyIterable;
	import org.eclipse.jpt.jpa.core.MappingKeys;
	import org.eclipse.jpt.jpa.core.context.AssociationOverride;
	import org.eclipse.jpt.jpa.core.context.AssociationOverrideContainer;
	import org.eclipse.jpt.jpa.core.context.AttributeMapping;
	import org.eclipse.jpt.jpa.core.context.OverrideContainer;
	import org.eclipse.jpt.jpa.core.context.ReadOnlyAssociationOverride;
	import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseColumn;
	import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumn;
	import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinTable;
	import org.eclipse.jpt.jpa.core.context.ReadOnlyOverride;
	import org.eclipse.jpt.jpa.core.context.ReadOnlyTable;
	import org.eclipse.jpt.jpa.core.context.Relationship;
	import org.eclipse.jpt.jpa.core.context.TypeMapping;
	import org.eclipse.jpt.jpa.core.context.java.JavaAssociationOverrideContainer;
	import org.eclipse.jpt.jpa.core.context.java.JavaAttributeOverrideContainer;
	import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute;
	import org.eclipse.jpt.jpa.core.internal.context.AttributeMappingTools;
	import org.eclipse.jpt.jpa.core.internal.context.BaseColumnTextRangeResolver;
	import org.eclipse.jpt.jpa.core.internal.context.JoinColumnTextRangeResolver;
	import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
	import org.eclipse.jpt.jpa.core.internal.context.MappingTools;
	import org.eclipse.jpt.jpa.core.internal.context.OverrideTextRangeResolver;
	import org.eclipse.jpt.jpa.core.internal.context.TableTextRangeResolver;
	import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaBaseEmbeddedMapping;
	import org.eclipse.jpt.jpa.core.internal.jpa1.context.AssociationOverrideInverseJoinColumnValidator;
	import org.eclipse.jpt.jpa.core.internal.jpa1.context.AssociationOverrideJoinColumnValidator;
	import org.eclipse.jpt.jpa.core.internal.jpa1.context.AssociationOverrideJoinTableValidator;
	import org.eclipse.jpt.jpa.core.internal.jpa1.context.AssociationOverrideValidator;
	import org.eclipse.jpt.jpa.core.internal.jpa1.context.EmbeddableOverrideDescriptionProvider;
	import org.eclipse.jpt.jpa.core.internal.jpa1.context.EntityTableDescriptionProvider;
	import org.eclipse.jpt.jpa.core.internal.jpa1.context.JoinTableTableDescriptionProvider;
	import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaAssociationOverrideContainer2_0;
	import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaEmbeddedMapping2_0;
	import org.eclipse.jpt.jpa.core.resource.java.EmbeddedAnnotation;
	import org.eclipse.wst.validation.internal.provisional.core.IMessage;
	import org.eclipse.wst.validation.internal.provisional.core.IReporter;

	/**
	* Java embedded mapping
	*/
	public class GenericJavaEmbeddedMapping
	extends AbstractJavaBaseEmbeddedMapping<EmbeddedAnnotation>
	implements JavaEmbeddedMapping2_0
	{
	protected final JavaAssociationOverrideContainer associationOverrideContainer;


	public GenericJavaEmbeddedMapping(JavaPersistentAttribute parent) {
	super(parent);
	this.associationOverrideContainer = this.buildAssociationOverrideContainer();
	}


	// ******** synchronize/update ********

	@Override
	public void synchronizeWithResourceModel() {
	super.synchronizeWithResourceModel();
	this.associationOverrideContainer.synchronizeWithResourceModel();
	}

	@Override
	public void update() {
	super.update();
	this.associationOverrideContainer.update();
	}


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

	protected JavaAssociationOverrideContainer buildAssociationOverrideContainer() {
	return this.isJpa2_0Compatible() ?
	this.getJpaFactory2_0().buildJavaAssociationOverrideContainer(this, this.buildAssociationOverrideContainerOwner()) :
	new GenericJavaAssociationOverrideContainer(this, null);
	}

	public JavaAssociationOverrideContainer getAssociationOverrideContainer() {
	return this.associationOverrideContainer;
	}

	protected JavaAssociationOverrideContainer.Owner buildAssociationOverrideContainerOwner() {
	return new AssociationOverrideContainerOwner();
	}


	// ******** embedded mappings ********

	/**
	* This is only to build the choices for a "mapped by" setting in a
	* relationship mapping. JPA 2.0 does not support relationship mappings
	* in an embedded ID class; so we only put this logic here.
	*/
	@Override
	@SuppressWarnings("unchecked")
	public Iterable<String> getAllMappingNames() {
	return this.isJpa2_0Compatible() ?
	new CompositeIterable<String>(super.getAllMappingNames(), this.getAllEmbeddableAttributeMappingNames()) :
	super.getAllMappingNames();
	}

	protected Iterable<String> getAllEmbeddableAttributeMappingNames() {
	return this.getQualifiedEmbeddableOverridableMappingNames(AttributeMappingTools.ALL_MAPPING_NAMES_TRANSFORMER);
	}

	@Override
	public AttributeMapping resolveAttributeMapping(String attributeName) {
	AttributeMapping resolvedMapping = super.resolveAttributeMapping(attributeName);
	if (resolvedMapping != null) {
	return resolvedMapping;
	}
	return this.isJpa2_0Compatible() ? this.resolveAttributeMapping_(attributeName) : null;
	}

	protected AttributeMapping resolveAttributeMapping_(String attributeName) {
	attributeName = this.unqualify(attributeName);
	if (attributeName == null) {
	return null;
	}
	// recurse into the embeddable mappings
	for (AttributeMapping mapping : this.getEmbeddableAttributeMappings()) {
	AttributeMapping resolvedMapping = mapping.resolveAttributeMapping(attributeName);
	if (resolvedMapping != null) {
	return resolvedMapping;
	}
	}
	return null;
	}


	// ******** misc ********

	public String getKey() {
	return MappingKeys.EMBEDDED_ATTRIBUTE_MAPPING_KEY;
	}

	@Override
	protected String getAnnotationName() {
	return EmbeddedAnnotation.ANNOTATION_NAME;
	}

	@Override
	public Relationship resolveOverriddenRelationship(String attributeName) {
	return this.isJpa2_0Compatible() ? this.resolveOverriddenRelationship_(attributeName) : null;
	}

	protected Relationship resolveOverriddenRelationship_(String attributeName) {
	attributeName = this.unqualify(attributeName);
	if (attributeName == null) {
	return null;
	}
	AssociationOverride override = this.associationOverrideContainer.getSpecifiedOverrideNamed(attributeName);
	// recurse into the target embeddable if necessary
	return (override != null) ? override.getRelationship() : this.resolveOverriddenRelationshipInTargetEmbeddable(attributeName);
	}

	protected Relationship resolveOverriddenRelationshipInTargetEmbeddable(String attributeName) {
	return (this.targetEmbeddable == null) ? null : this.targetEmbeddable.resolveOverriddenRelationship(attributeName);
	}

	@Override
	protected JavaAttributeOverrideContainer.Owner buildAttributeOverrideContainerOwner() {
	return new AttributeOverrideContainerOwner();
	}


	// ******** Java completion proposals ********

	@Override
	public Iterable<String> getJavaCompletionProposals(int pos, Filter<String> filter, CompilationUnit astRoot) {
	Iterable<String> result = super.getJavaCompletionProposals(pos, filter, astRoot);
	if (result != null) {
	return result;
	}

	result = this.associationOverrideContainer.getJavaCompletionProposals(pos, filter, astRoot);
	if (result != null) {
	return result;
	}

	return null;
	}


	// ******** validation ********

	@Override
	protected void validateOverrides(List<IMessage> messages, IReporter reporter, CompilationUnit astRoot) {
	super.validateOverrides(messages, reporter, astRoot);
	this.associationOverrideContainer.validate(messages, reporter, astRoot);
	}


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

	protected class AttributeOverrideContainerOwner
	extends AbstractJavaBaseEmbeddedMapping<EmbeddedAnnotation>.AttributeOverrideContainerOwner
	{
	// nothing yet
	}


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

	protected class AssociationOverrideContainerOwner
	implements JavaAssociationOverrideContainer2_0.Owner
	{
	public JavaResourceAttribute getResourceMember() {
	return GenericJavaEmbeddedMapping.this.getResourceAttribute();
	}

	public TypeMapping getTypeMapping() {
	return GenericJavaEmbeddedMapping.this.getTypeMapping();
	}

	public TypeMapping getOverridableTypeMapping() {
	return GenericJavaEmbeddedMapping.this.getTargetEmbeddable();
	}

	public Iterable<String> getAllOverridableNames() {
	TypeMapping typeMapping = this.getOverridableTypeMapping();
	return (typeMapping != null) ? typeMapping.getAllOverridableAssociationNames() : EmptyIterable.<String>instance();
	}

	public Relationship resolveOverriddenRelationship(String attributeName) {
	return MappingTools.resolveOverriddenRelationship(this.getOverridableTypeMapping(), attributeName);
	}

	public boolean tableNameIsInvalid(String tableName) {
	return this.getTypeMapping().tableNameIsInvalid(tableName);
	}

	public Iterable<String> getCandidateTableNames() {
	return this.getTypeMapping().getAllAssociatedTableNames();
	}

	public org.eclipse.jpt.jpa.db.Table resolveDbTable(String tableName) {
	return this.getTypeMapping().resolveDbTable(tableName);
	}

	public String getDefaultTableName() {
	return this.getTypeMapping().getPrimaryTableName();
	}

	public String getPossiblePrefix() {
	return null;
	}

	public String getWritePrefix() {
	return null;
	}

	// no maps, so all overrides are relevant
	public boolean isRelevant(String overrideName) {
	return true;
	}

	public TextRange getValidationTextRange(CompilationUnit astRoot) {
	return GenericJavaEmbeddedMapping.this.getValidationTextRange(astRoot);
	}

	public JptValidator buildOverrideValidator(ReadOnlyOverride override, OverrideContainer container, OverrideTextRangeResolver textRangeResolver) {
	return new AssociationOverrideValidator(this.getPersistentAttribute(), (ReadOnlyAssociationOverride) override, (AssociationOverrideContainer) container, textRangeResolver, new EmbeddableOverrideDescriptionProvider());
	}

	public JptValidator buildColumnValidator(ReadOnlyOverride override, ReadOnlyBaseColumn column, ReadOnlyBaseColumn.Owner owner, BaseColumnTextRangeResolver textRangeResolver) {
	return new AssociationOverrideJoinColumnValidator(this.getPersistentAttribute(), (ReadOnlyAssociationOverride) override, (ReadOnlyJoinColumn) column, (ReadOnlyJoinColumn.Owner) owner, (JoinColumnTextRangeResolver) textRangeResolver, new EntityTableDescriptionProvider());
	}

	public JptValidator buildJoinTableJoinColumnValidator(ReadOnlyAssociationOverride override, ReadOnlyJoinColumn column, ReadOnlyJoinColumn.Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
	return new AssociationOverrideJoinColumnValidator(this.getPersistentAttribute(), override, column, owner, textRangeResolver, new JoinTableTableDescriptionProvider());
	}

	public JptValidator buildJoinTableInverseJoinColumnValidator(ReadOnlyAssociationOverride override, ReadOnlyJoinColumn column, ReadOnlyJoinColumn.Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
	return new AssociationOverrideInverseJoinColumnValidator(this.getPersistentAttribute(), override, column, owner, textRangeResolver, new JoinTableTableDescriptionProvider());
	}

	public JptValidator buildJoinTableValidator(ReadOnlyAssociationOverride override, ReadOnlyTable table, TableTextRangeResolver textRangeResolver) {
	return new AssociationOverrideJoinTableValidator(this.getPersistentAttribute(), override, (ReadOnlyJoinTable) table, textRangeResolver);
	}

	protected JavaPersistentAttribute getPersistentAttribute() {
	return GenericJavaEmbeddedMapping.this.getPersistentAttribute();
	}
	}
	}