| /******************************************************************************* |
| * Copyright (c) 2006, 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.context.orm; |
| |
| import java.util.List; |
| import org.eclipse.jdt.core.IPackageFragment; |
| import org.eclipse.jdt.core.IType; |
| import org.eclipse.jpt.common.core.resource.java.JavaResourceType; |
| import org.eclipse.jpt.common.core.utility.TextRange; |
| import org.eclipse.jpt.common.utility.internal.CollectionTools; |
| import org.eclipse.jpt.common.utility.internal.StringTools; |
| import org.eclipse.jpt.common.utility.internal.Tools; |
| import org.eclipse.jpt.common.utility.internal.iterables.CompositeIterable; |
| import org.eclipse.jpt.common.utility.internal.iterables.EmptyIterable; |
| import org.eclipse.jpt.common.utility.internal.iterables.FilteringIterable; |
| import org.eclipse.jpt.common.utility.internal.iterables.SingleElementIterable; |
| import org.eclipse.jpt.common.utility.internal.iterables.TransformationIterable; |
| import org.eclipse.jpt.jpa.core.JpaStructureNode; |
| import org.eclipse.jpt.jpa.core.context.AttributeMapping; |
| import org.eclipse.jpt.jpa.core.context.Column; |
| import org.eclipse.jpt.jpa.core.context.PersistentType; |
| import org.eclipse.jpt.jpa.core.context.Relationship; |
| import org.eclipse.jpt.jpa.core.context.TypeMapping; |
| import org.eclipse.jpt.jpa.core.context.java.JavaPersistentType; |
| import org.eclipse.jpt.jpa.core.context.java.JavaTypeMapping; |
| import org.eclipse.jpt.jpa.core.context.orm.OrmPersistentType; |
| import org.eclipse.jpt.jpa.core.context.orm.OrmReadOnlyPersistentAttribute; |
| import org.eclipse.jpt.jpa.core.context.orm.OrmTypeMapping; |
| import org.eclipse.jpt.jpa.core.internal.context.AttributeMappingTools; |
| import org.eclipse.jpt.jpa.core.internal.context.JptValidator; |
| import org.eclipse.jpt.jpa.core.internal.context.TypeMappingTextRangeResolver; |
| import org.eclipse.jpt.jpa.core.internal.context.TypeMappingTools; |
| import org.eclipse.jpt.jpa.core.internal.jpa1.context.GenericTypeMappingValidator; |
| import org.eclipse.jpt.jpa.core.internal.validation.DefaultJpaValidationMessages; |
| import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages; |
| import org.eclipse.jpt.jpa.core.resource.orm.XmlTypeMapping; |
| import org.eclipse.jpt.jpa.db.Schema; |
| import org.eclipse.jpt.jpa.db.Table; |
| import org.eclipse.text.edits.DeleteEdit; |
| import org.eclipse.text.edits.ReplaceEdit; |
| import org.eclipse.wst.validation.internal.provisional.core.IMessage; |
| import org.eclipse.wst.validation.internal.provisional.core.IReporter; |
| |
| /** |
| * <code>orm.xml</code> type mapping |
| */ |
| public abstract class AbstractOrmTypeMapping<X extends XmlTypeMapping> |
| extends AbstractOrmXmlContextNode |
| implements OrmTypeMapping |
| { |
| // never null |
| protected final X xmlTypeMapping; |
| |
| protected String class_; |
| |
| protected Boolean specifiedMetadataComplete; |
| protected boolean overrideMetadataComplete; |
| |
| |
| protected AbstractOrmTypeMapping(OrmPersistentType parent, X xmlTypeMapping) { |
| super(parent); |
| this.xmlTypeMapping = xmlTypeMapping; |
| this.class_ = xmlTypeMapping.getClassName(); |
| this.specifiedMetadataComplete = xmlTypeMapping.getMetadataComplete(); |
| } |
| |
| |
| // ********** synchronize/update ********** |
| |
| @Override |
| public void synchronizeWithResourceModel() { |
| super.synchronizeWithResourceModel(); |
| this.setClass_(this.xmlTypeMapping.getClassName()); |
| this.setSpecifiedMetadataComplete_(this.xmlTypeMapping.getMetadataComplete()); |
| } |
| |
| @Override |
| public void update() { |
| super.update(); |
| this.setOverrideMetadataComplete(this.buildOverrideMetadataComplete()); |
| } |
| |
| |
| // ********** class ********** |
| |
| public String getClass_() { |
| return this.class_; |
| } |
| |
| public void setClass(String class_) { |
| this.setClass_(class_); |
| this.xmlTypeMapping.setClassName(class_); |
| } |
| |
| protected void setClass_(String class_) { |
| String old = this.class_; |
| this.class_ = class_; |
| if (this.firePropertyChanged(CLASS_PROPERTY, old, class_)) { |
| this.getPersistentType().mappingClassChanged(old, class_); |
| } |
| } |
| |
| |
| // ********** metadata complete ********** |
| |
| /** |
| * If <code>entity-mappings/persistence-unit-metadata/xml-mapping-metadata-complete</code> |
| * is specified, it overrides anything set here. |
| */ |
| public boolean isMetadataComplete() { |
| if (this.overrideMetadataComplete) { |
| return true; |
| } |
| return (this.specifiedMetadataComplete != null) ? this.specifiedMetadataComplete.booleanValue() : false; |
| } |
| |
| public Boolean getSpecifiedMetadataComplete() { |
| return this.specifiedMetadataComplete; |
| } |
| |
| public void setSpecifiedMetadataComplete(Boolean metadataComplete) { |
| this.setSpecifiedMetadataComplete_(metadataComplete); |
| this.xmlTypeMapping.setMetadataComplete(metadataComplete); |
| } |
| |
| protected void setSpecifiedMetadataComplete_(Boolean metadataComplete) { |
| Boolean old = this.specifiedMetadataComplete; |
| this.specifiedMetadataComplete = metadataComplete; |
| this.firePropertyChanged(SPECIFIED_METADATA_COMPLETE_PROPERTY, old, metadataComplete); |
| } |
| |
| public boolean isOverrideMetadataComplete() { |
| return this.overrideMetadataComplete; |
| } |
| |
| protected void setOverrideMetadataComplete(boolean metadataComplete) { |
| boolean old = this.overrideMetadataComplete; |
| this.overrideMetadataComplete = metadataComplete; |
| this.firePropertyChanged(OVERRIDE_METADATA_COMPLETE_PROPERTY, old, metadataComplete); |
| } |
| |
| protected boolean buildOverrideMetadataComplete() { |
| return this.getPersistenceUnit().isXmlMappingMetadataComplete(); |
| } |
| |
| |
| // ********** Java type mapping ********** |
| |
| public JavaTypeMapping getJavaTypeMapping() { |
| JavaPersistentType javaType = this.getJavaPersistentType(); |
| if (javaType == null) { |
| return null; |
| } |
| return (javaType.getMappingKey() == this.getKey()) ? javaType.getMapping() : null; |
| } |
| |
| public JavaTypeMapping getJavaTypeMappingForDefaults() { |
| return this.isMetadataComplete() ? null : this.getJavaTypeMapping(); |
| } |
| |
| |
| // ********** misc ********** |
| |
| @Override |
| public OrmPersistentType getParent() { |
| return (OrmPersistentType) super.getParent(); |
| } |
| |
| public OrmPersistentType getPersistentType() { |
| return this.getParent(); |
| } |
| |
| public String getName() { |
| return this.getPersistentType().getName(); |
| } |
| |
| protected JavaPersistentType getJavaPersistentType() { |
| return this.getPersistentType().getJavaPersistentType(); |
| } |
| |
| protected JavaResourceType getJavaResourceType() { |
| JavaPersistentType javaType = this.getJavaPersistentType(); |
| return (javaType == null) ? null : javaType.getJavaResourceType(); |
| } |
| |
| public boolean isMapped() { |
| return true; |
| } |
| |
| /** |
| * A type's mapping is being changed. Copy the common settings from the old |
| * mapping to the new (this). |
| */ |
| public void initializeFrom(OrmTypeMapping oldMapping) { |
| this.setClass(oldMapping.getClass_()); |
| this.setSpecifiedMetadataComplete(oldMapping.getSpecifiedMetadataComplete()); |
| this.setOverrideMetadataComplete(oldMapping.isOverrideMetadataComplete()); |
| } |
| |
| public X getXmlTypeMapping() { |
| return this.xmlTypeMapping; |
| } |
| |
| public boolean attributeIsDerivedId(String attributeName) { |
| return TypeMappingTools.attributeIsDerivedId(this, attributeName); |
| } |
| |
| @Override |
| public void toString(StringBuilder sb) { |
| sb.append(this.getPersistentType().getName()); |
| } |
| |
| |
| // ********** tables ********** |
| |
| public String getPrimaryTableName() { |
| return null; |
| } |
| |
| public Table getPrimaryDbTable() { |
| return null; |
| } |
| |
| public Table resolveDbTable(String tableName) { |
| return null; |
| } |
| |
| public Schema getDbSchema() { |
| return null; |
| } |
| |
| |
| // ********** attribute mappings ********** |
| |
| public boolean attributeMappingKeyAllowed(String attributeMappingKey) { |
| return true; |
| } |
| |
| public Iterable<AttributeMapping> getAttributeMappings() { |
| return new TransformationIterable<OrmReadOnlyPersistentAttribute, AttributeMapping>(this.getPersistentType().getAttributes()) { |
| @Override |
| protected AttributeMapping transform(OrmReadOnlyPersistentAttribute attribute) { |
| return attribute.getMapping(); |
| } |
| }; |
| } |
| |
| public Iterable<AttributeMapping> getAllAttributeMappings() { |
| return new CompositeIterable<AttributeMapping>(this.getAllAttributeMappingsLists()); |
| } |
| |
| protected Iterable<Iterable<AttributeMapping>> getAllAttributeMappingsLists() { |
| return new TransformationIterable<TypeMapping, Iterable<AttributeMapping>>(this.getInheritanceHierarchy(), TypeMappingTools.ATTRIBUTE_MAPPINGS_TRANSFORMER); |
| } |
| |
| public Iterable<String> getOverridableAttributeNames() { |
| return new CompositeIterable<String>(this.getOverridableAttributeNamesLists()); |
| } |
| |
| protected Iterable<Iterable<String>> getOverridableAttributeNamesLists() { |
| return new TransformationIterable<AttributeMapping, Iterable<String>>(this.getAttributeMappings(), AttributeMappingTools.ALL_OVERRIDABLE_ATTRIBUTE_MAPPING_NAMES_TRANSFORMER); |
| } |
| |
| public Iterable<String> getAllOverridableAttributeNames() { |
| return new CompositeIterable<String>(this.getAllOverridableAttributeNamesLists()); |
| } |
| |
| protected Iterable<Iterable<String>> getAllOverridableAttributeNamesLists() { |
| return new TransformationIterable<TypeMapping, Iterable<String>>(this.getInheritanceHierarchy(), TypeMappingTools.OVERRIDABLE_ATTRIBUTE_NAMES_TRANSFORMER); |
| } |
| |
| public Iterable<AttributeMapping> getAttributeMappings(final String mappingKey) { |
| return new FilteringIterable<AttributeMapping>(CollectionTools.collection(this.getAttributeMappings())) { |
| @Override |
| protected boolean accept(AttributeMapping o) { |
| return Tools.valuesAreEqual(o.getKey(), mappingKey); |
| } |
| }; |
| } |
| |
| public Iterable<AttributeMapping> getAllAttributeMappings(final String mappingKey) { |
| return new FilteringIterable<AttributeMapping>(CollectionTools.collection(this.getAllAttributeMappings())) { |
| @Override |
| protected boolean accept(AttributeMapping o) { |
| return Tools.valuesAreEqual(o.getKey(), mappingKey); |
| } |
| }; |
| } |
| |
| public Column resolveOverriddenColumn(String attributeName) { |
| for (AttributeMapping attributeMapping : this.getAttributeMappings()) { |
| Column column = attributeMapping.resolveOverriddenColumn(attributeName); |
| if (column != null) { |
| return column; |
| } |
| } |
| if ( ! this.isMetadataComplete()) { |
| JavaPersistentType javaPersistentType = this.getJavaPersistentType(); |
| if (javaPersistentType != null) { |
| return javaPersistentType.getMapping().resolveOverriddenColumn(attributeName); |
| } |
| } |
| return null; |
| } |
| |
| public Iterable<String> getOverridableAssociationNames() { |
| return new CompositeIterable<String>(this.getOverridableAssociationNamesLists()); |
| } |
| |
| protected Iterable<Iterable<String>> getOverridableAssociationNamesLists() { |
| return new TransformationIterable<AttributeMapping, Iterable<String>>(this.getAttributeMappings(), AttributeMappingTools.ALL_OVERRIDABLE_ASSOCIATION_MAPPING_NAMES_TRANSFORMER); |
| } |
| |
| public Iterable<String> getAllOverridableAssociationNames() { |
| return new CompositeIterable<String>(this.getAllOverridableAssociationNamesLists()); |
| } |
| |
| protected Iterable<Iterable<String>> getAllOverridableAssociationNamesLists() { |
| return new TransformationIterable<TypeMapping, Iterable<String>>(this.getInheritanceHierarchy(), TypeMappingTools.OVERRIDABLE_ASSOCIATION_NAMES_TRANSFORMER); |
| } |
| |
| public Relationship resolveOverriddenRelationship(String attributeName) { |
| for (AttributeMapping attributeMapping : this.getAttributeMappings()) { |
| Relationship relationship = attributeMapping.resolveOverriddenRelationship(attributeName); |
| if (relationship != null) { |
| return relationship; |
| } |
| } |
| if ( ! this.isMetadataComplete()) { |
| JavaPersistentType javaPersistentType = this.getJavaPersistentType(); |
| if (javaPersistentType != null) { |
| return javaPersistentType.getMapping().resolveOverriddenRelationship(attributeName); |
| } |
| } |
| return null; |
| } |
| |
| |
| // ********** inheritance hierarchy ********** |
| |
| public TypeMapping getSuperTypeMapping() { |
| PersistentType superPersistentType = this.getPersistentType().getSuperPersistentType(); |
| return (superPersistentType == null) ? null : superPersistentType.getMapping(); |
| } |
| |
| public Iterable<TypeMapping> getInheritanceHierarchy() { |
| return this.convertToMappings(this.getPersistentType().getInheritanceHierarchy()); |
| } |
| |
| /** |
| * Return the type mapping's "persistence" ancestors, |
| * <em>excluding</em> the type mapping itself. |
| * The returned iterator will return elements infinitely if the hierarchy |
| * has a loop. |
| */ |
| protected Iterable<TypeMapping> getAncestors() { |
| return this.convertToMappings(this.getPersistentType().getAncestors()); |
| } |
| |
| protected Iterable<TypeMapping> convertToMappings(Iterable<PersistentType> types) { |
| return new TransformationIterable<PersistentType, TypeMapping>(types) { |
| @Override |
| protected TypeMapping transform(PersistentType type) { |
| return type.getMapping(); |
| } |
| }; |
| } |
| |
| |
| // ********** text ranges ********** |
| |
| public JpaStructureNode getStructureNode(int offset) { |
| return this.xmlTypeMapping.containsOffset(offset) ? this.getPersistentType() : null; |
| } |
| |
| public TextRange getSelectionTextRange() { |
| return this.xmlTypeMapping.getSelectionTextRange(); |
| } |
| |
| public TextRange getClassTextRange() { |
| return this.getValidationTextRange(this.xmlTypeMapping.getClassTextRange()); |
| } |
| |
| public TextRange getAttributesTextRange() { |
| return this.getValidationTextRange(this.xmlTypeMapping.getAttributesTextRange()); |
| } |
| |
| public TextRange getNameTextRange() { |
| return this.getValidationTextRange(this.xmlTypeMapping.getNameTextRange()); |
| } |
| |
| public boolean containsOffset(int textOffset) { |
| return this.xmlTypeMapping.containsOffset(textOffset); |
| } |
| |
| |
| // ********** refactoring ********** |
| |
| public DeleteEdit createDeleteEdit() { |
| return this.xmlTypeMapping.createDeleteEdit(); |
| } |
| |
| public Iterable<ReplaceEdit> createRenameTypeEdits(IType originalType, String newName) { |
| return this.getPersistentType().isFor(originalType.getFullyQualifiedName('.')) ? |
| new SingleElementIterable<ReplaceEdit>(this.createRenameTypeEdit(originalType, newName)) : |
| EmptyIterable.<ReplaceEdit>instance(); |
| } |
| |
| protected ReplaceEdit createRenameTypeEdit(IType originalType, String newName) { |
| return this.xmlTypeMapping.createRenameTypeEdit(originalType, newName); |
| } |
| |
| public Iterable<ReplaceEdit> createMoveTypeEdits(IType originalType, IPackageFragment newPackage) { |
| return this.getPersistentType().isFor(originalType.getFullyQualifiedName('.')) ? |
| new SingleElementIterable<ReplaceEdit>(this.createRenamePackageEdit(newPackage.getElementName())) : |
| EmptyIterable.<ReplaceEdit>instance(); |
| } |
| |
| public Iterable<ReplaceEdit> createRenamePackageEdits(IPackageFragment originalPackage, String newName) { |
| return this.getPersistentType().isIn(originalPackage) ? |
| new SingleElementIterable<ReplaceEdit>(this.createRenamePackageEdit(newName)) : |
| EmptyIterable.<ReplaceEdit>instance(); |
| } |
| |
| protected ReplaceEdit createRenamePackageEdit(String newName) { |
| return this.xmlTypeMapping.createRenamePackageEdit(newName); |
| } |
| |
| |
| // ********** validation ********** |
| |
| @Override |
| public void validate(List<IMessage> messages, IReporter reporter) { |
| super.validate(messages, reporter); |
| this.validateClass(messages, reporter); |
| } |
| |
| protected void validateClass(List<IMessage> messages, IReporter reporter) { |
| if (StringTools.stringIsEmpty(this.class_)) { |
| messages.add( |
| DefaultJpaValidationMessages.buildMessage( |
| IMessage.HIGH_SEVERITY, |
| JpaValidationMessages.PERSISTENT_TYPE_UNSPECIFIED_CLASS, |
| this, |
| this.getClassTextRange() |
| ) |
| ); |
| return; |
| } |
| this.buildTypeMappingValidator().validate(messages, reporter); |
| } |
| |
| protected JptValidator buildTypeMappingValidator() { |
| return new GenericTypeMappingValidator(this, this.getJavaResourceType(), this.buildTextRangeResolver()); |
| } |
| |
| protected TypeMappingTextRangeResolver buildTextRangeResolver() { |
| return new OrmTypeMappingTextRangeResolver(this); |
| } |
| |
| public boolean validatesAgainstDatabase() { |
| return this.getPersistenceUnit().validatesAgainstDatabase(); |
| } |
| |
| public TextRange getValidationTextRange() { |
| TextRange textRange = this.xmlTypeMapping.getValidationTextRange(); |
| return (textRange != null) ? textRange : this.getPersistentType().getValidationTextRange(); |
| } |
| } |