| /******************************************************************************* |
| * Copyright (c) 2006, 2008 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.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.jdt.core.dom.CompilationUnit; |
| import org.eclipse.jpt.core.MappingKeys; |
| import org.eclipse.jpt.core.context.AssociationOverride; |
| import org.eclipse.jpt.core.context.AttributeOverride; |
| import org.eclipse.jpt.core.context.BaseJoinColumn; |
| import org.eclipse.jpt.core.context.BaseOverride; |
| import org.eclipse.jpt.core.context.ColumnMapping; |
| import org.eclipse.jpt.core.context.DiscriminatorColumn; |
| import org.eclipse.jpt.core.context.DiscriminatorType; |
| import org.eclipse.jpt.core.context.Entity; |
| import org.eclipse.jpt.core.context.Generator; |
| import org.eclipse.jpt.core.context.IdClass; |
| import org.eclipse.jpt.core.context.InheritanceType; |
| import org.eclipse.jpt.core.context.NamedNativeQuery; |
| import org.eclipse.jpt.core.context.NamedQuery; |
| import org.eclipse.jpt.core.context.PersistentAttribute; |
| import org.eclipse.jpt.core.context.PersistentType; |
| import org.eclipse.jpt.core.context.PrimaryKeyJoinColumn; |
| import org.eclipse.jpt.core.context.Query; |
| import org.eclipse.jpt.core.context.QueryHolder; |
| import org.eclipse.jpt.core.context.RelationshipMapping; |
| import org.eclipse.jpt.core.context.SecondaryTable; |
| import org.eclipse.jpt.core.context.Table; |
| import org.eclipse.jpt.core.context.TypeMapping; |
| import org.eclipse.jpt.core.context.java.JavaAssociationOverride; |
| import org.eclipse.jpt.core.context.java.JavaAttributeOverride; |
| import org.eclipse.jpt.core.context.java.JavaBaseJoinColumn; |
| import org.eclipse.jpt.core.context.java.JavaDiscriminatorColumn; |
| import org.eclipse.jpt.core.context.java.JavaEntity; |
| import org.eclipse.jpt.core.context.java.JavaGenerator; |
| import org.eclipse.jpt.core.context.java.JavaNamedColumn; |
| import org.eclipse.jpt.core.context.java.JavaNamedNativeQuery; |
| import org.eclipse.jpt.core.context.java.JavaNamedQuery; |
| import org.eclipse.jpt.core.context.java.JavaPersistentType; |
| import org.eclipse.jpt.core.context.java.JavaPrimaryKeyJoinColumn; |
| import org.eclipse.jpt.core.context.java.JavaQuery; |
| import org.eclipse.jpt.core.context.java.JavaSecondaryTable; |
| import org.eclipse.jpt.core.context.java.JavaSequenceGenerator; |
| import org.eclipse.jpt.core.context.java.JavaTable; |
| import org.eclipse.jpt.core.context.java.JavaTableGenerator; |
| import org.eclipse.jpt.core.internal.resource.java.NullAssociationOverride; |
| import org.eclipse.jpt.core.internal.resource.java.NullPrimaryKeyJoinColumn; |
| import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages; |
| import org.eclipse.jpt.core.internal.validation.JpaValidationMessages; |
| import org.eclipse.jpt.core.resource.java.AssociationOverrideAnnotation; |
| import org.eclipse.jpt.core.resource.java.AssociationOverridesAnnotation; |
| import org.eclipse.jpt.core.resource.java.AttributeOverrideAnnotation; |
| import org.eclipse.jpt.core.resource.java.AttributeOverridesAnnotation; |
| import org.eclipse.jpt.core.resource.java.DiscriminatorValueAnnotation; |
| import org.eclipse.jpt.core.resource.java.EntityAnnotation; |
| import org.eclipse.jpt.core.resource.java.IdClassAnnotation; |
| import org.eclipse.jpt.core.resource.java.InheritanceAnnotation; |
| import org.eclipse.jpt.core.resource.java.JPA; |
| import org.eclipse.jpt.core.resource.java.JavaResourceNode; |
| import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType; |
| import org.eclipse.jpt.core.resource.java.NamedNativeQueriesAnnotation; |
| import org.eclipse.jpt.core.resource.java.NamedNativeQueryAnnotation; |
| import org.eclipse.jpt.core.resource.java.NamedQueriesAnnotation; |
| import org.eclipse.jpt.core.resource.java.NamedQueryAnnotation; |
| import org.eclipse.jpt.core.resource.java.PrimaryKeyJoinColumnAnnotation; |
| import org.eclipse.jpt.core.resource.java.PrimaryKeyJoinColumns; |
| import org.eclipse.jpt.core.resource.java.SecondaryTableAnnotation; |
| import org.eclipse.jpt.core.resource.java.SecondaryTablesAnnotation; |
| import org.eclipse.jpt.core.resource.java.SequenceGeneratorAnnotation; |
| import org.eclipse.jpt.core.resource.java.TableGeneratorAnnotation; |
| import org.eclipse.jpt.core.utility.TextRange; |
| import org.eclipse.jpt.db.Schema; |
| import org.eclipse.jpt.utility.Filter; |
| import org.eclipse.jpt.utility.internal.CollectionTools; |
| import org.eclipse.jpt.utility.internal.iterators.ArrayIterator; |
| import org.eclipse.jpt.utility.internal.iterators.CloneListIterator; |
| import org.eclipse.jpt.utility.internal.iterators.CompositeIterator; |
| import org.eclipse.jpt.utility.internal.iterators.CompositeListIterator; |
| import org.eclipse.jpt.utility.internal.iterators.EmptyIterator; |
| import org.eclipse.jpt.utility.internal.iterators.EmptyListIterator; |
| import org.eclipse.jpt.utility.internal.iterators.FilteringIterator; |
| import org.eclipse.jpt.utility.internal.iterators.SingleElementIterator; |
| import org.eclipse.jpt.utility.internal.iterators.SingleElementListIterator; |
| import org.eclipse.jpt.utility.internal.iterators.TransformationIterator; |
| import org.eclipse.wst.validation.internal.provisional.core.IMessage; |
| |
| |
| public class GenericJavaEntity extends AbstractJavaTypeMapping implements JavaEntity |
| { |
| protected EntityAnnotation entityResource; |
| |
| protected String specifiedName; |
| |
| protected String defaultName; |
| |
| protected final JavaTable table; |
| |
| protected final List<JavaSecondaryTable> specifiedSecondaryTables; |
| |
| protected final List<JavaPrimaryKeyJoinColumn> specifiedPrimaryKeyJoinColumns; |
| |
| protected JavaPrimaryKeyJoinColumn defaultPrimaryKeyJoinColumn; |
| |
| protected InheritanceType specifiedInheritanceStrategy; |
| |
| protected InheritanceType defaultInheritanceStrategy; |
| |
| protected String defaultDiscriminatorValue; |
| |
| protected boolean discriminatorValueAllowed; |
| |
| protected String specifiedDiscriminatorValue; |
| |
| protected final JavaDiscriminatorColumn discriminatorColumn; |
| |
| protected JavaSequenceGenerator sequenceGenerator; |
| |
| protected JavaTableGenerator tableGenerator; |
| |
| protected final List<JavaAttributeOverride> specifiedAttributeOverrides; |
| |
| protected final List<JavaAttributeOverride> virtualAttributeOverrides; |
| |
| protected final List<JavaAssociationOverride> specifiedAssociationOverrides; |
| |
| protected final List<JavaAssociationOverride> virtualAssociationOverrides; |
| |
| protected final List<JavaNamedQuery> namedQueries; |
| |
| protected final List<JavaNamedNativeQuery> namedNativeQueries; |
| |
| protected String idClass; |
| |
| |
| public GenericJavaEntity(JavaPersistentType parent) { |
| super(parent); |
| this.table = getJpaFactory().buildJavaTable(this); |
| this.discriminatorColumn = buildJavaDiscriminatorColumn(); |
| this.specifiedSecondaryTables = new ArrayList<JavaSecondaryTable>(); |
| this.specifiedPrimaryKeyJoinColumns = new ArrayList<JavaPrimaryKeyJoinColumn>(); |
| this.specifiedAttributeOverrides = new ArrayList<JavaAttributeOverride>(); |
| this.virtualAttributeOverrides = new ArrayList<JavaAttributeOverride>(); |
| this.namedQueries = new ArrayList<JavaNamedQuery>(); |
| this.namedNativeQueries = new ArrayList<JavaNamedNativeQuery>(); |
| this.specifiedAssociationOverrides = new ArrayList<JavaAssociationOverride>(); |
| this.virtualAssociationOverrides = new ArrayList<JavaAssociationOverride>(); |
| } |
| |
| protected JavaBaseJoinColumn.Owner createPrimaryKeyJoinColumnOwner() { |
| return new PrimaryKeyJoinColumnOwner(); |
| } |
| |
| protected JavaDiscriminatorColumn buildJavaDiscriminatorColumn() { |
| return getJpaFactory().buildJavaDiscriminatorColumn(this, buildDiscriminatorColumnOwner()); |
| } |
| |
| protected JavaNamedColumn.Owner buildDiscriminatorColumnOwner() { |
| return new JavaNamedColumn.Owner(){ |
| public org.eclipse.jpt.db.Table getDbTable(String tableName) { |
| return GenericJavaEntity.this.getDbTable(tableName); |
| } |
| |
| public TextRange getValidationTextRange(CompilationUnit astRoot) { |
| return GenericJavaEntity.this.getValidationTextRange(astRoot); |
| } |
| |
| public TypeMapping getTypeMapping() { |
| return GenericJavaEntity.this; |
| } |
| |
| public String getDefaultColumnName() { |
| return DiscriminatorColumn.DEFAULT_NAME; |
| } |
| }; |
| } |
| |
| @Override |
| public void initializeFromResource(JavaResourcePersistentType resourcePersistentType) { |
| super.initializeFromResource(resourcePersistentType); |
| this.entityResource = (EntityAnnotation) resourcePersistentType.getMappingAnnotation(EntityAnnotation.ANNOTATION_NAME); |
| |
| this.specifiedName = this.specifiedName(this.entityResource); |
| this.defaultName = this.defaultName(resourcePersistentType); |
| this.defaultInheritanceStrategy = this.defaultInheritanceStrategy(); |
| this.specifiedInheritanceStrategy = this.specifiedInheritanceStrategy(getInheritanceResource()); |
| this.specifiedDiscriminatorValue = this.getDiscriminatorValueResource().getValue(); |
| this.defaultDiscriminatorValue = this.javaDefaultDiscriminatorValue(); |
| this.discriminatorValueAllowed = this.discriminatorValueIsAllowed(resourcePersistentType); |
| this.discriminatorColumn.initializeFromResource(resourcePersistentType); |
| this.table.initializeFromResource(resourcePersistentType); |
| this.initializeSecondaryTables(resourcePersistentType); |
| this.initializeTableGenerator(resourcePersistentType); |
| this.initializeSequenceGenerator(resourcePersistentType); |
| this.initializePrimaryKeyJoinColumns(resourcePersistentType); |
| this.initializeDefaultPrimaryKeyJoinColumn(resourcePersistentType); |
| this.initializeSpecifiedAttributeOverrides(resourcePersistentType); |
| this.initializeVirtualAttributeOverrides(resourcePersistentType); |
| this.initializeSpecifiedAssociationOverrides(resourcePersistentType); |
| this.initializeDefaultAssociationOverrides(resourcePersistentType); |
| this.initializeNamedQueries(resourcePersistentType); |
| this.initializeNamedNativeQueries(resourcePersistentType); |
| this.initializeIdClass(resourcePersistentType); |
| this.updatePersistenceUnitGeneratorsAndQueries(); |
| } |
| |
| protected void initializeSecondaryTables(JavaResourcePersistentType resourcePersistentType) { |
| ListIterator<JavaResourceNode> annotations = resourcePersistentType.annotations(SecondaryTableAnnotation.ANNOTATION_NAME, SecondaryTablesAnnotation.ANNOTATION_NAME); |
| |
| while(annotations.hasNext()) { |
| this.specifiedSecondaryTables.add(buildSecondaryTable((SecondaryTableAnnotation) annotations.next())); |
| } |
| } |
| |
| protected void initializeTableGenerator(JavaResourcePersistentType resourcePersistentType) { |
| TableGeneratorAnnotation tableGeneratorResource = tableGenerator(resourcePersistentType); |
| if (tableGeneratorResource != null) { |
| this.tableGenerator = buildTableGenerator(tableGeneratorResource); |
| } |
| } |
| |
| protected void initializeSequenceGenerator(JavaResourcePersistentType resourcePersistentType) { |
| SequenceGeneratorAnnotation sequenceGeneratorResource = sequenceGenerator(resourcePersistentType); |
| if (sequenceGeneratorResource != null) { |
| this.sequenceGenerator = buildSequenceGenerator(sequenceGeneratorResource); |
| } |
| } |
| |
| protected void initializePrimaryKeyJoinColumns(JavaResourcePersistentType resourcePersistentType) { |
| ListIterator<JavaResourceNode> annotations = resourcePersistentType.annotations(PrimaryKeyJoinColumnAnnotation.ANNOTATION_NAME, PrimaryKeyJoinColumns.ANNOTATION_NAME); |
| |
| while(annotations.hasNext()) { |
| this.specifiedPrimaryKeyJoinColumns.add(buildPrimaryKeyJoinColumn((PrimaryKeyJoinColumnAnnotation) annotations.next())); |
| } |
| } |
| |
| protected boolean shouldBuildDefaultPrimaryKeyJoinColumn() { |
| return !containsSpecifiedPrimaryKeyJoinColumns(); |
| } |
| |
| protected void initializeDefaultPrimaryKeyJoinColumn(JavaResourcePersistentType persistentTypeResource) { |
| if (!shouldBuildDefaultPrimaryKeyJoinColumn()) { |
| return; |
| } |
| this.defaultPrimaryKeyJoinColumn = buildPrimaryKeyJoinColumn(new NullPrimaryKeyJoinColumn(persistentTypeResource)); |
| } |
| |
| protected void initializeSpecifiedAttributeOverrides(JavaResourcePersistentType persistentTypeResource) { |
| ListIterator<JavaResourceNode> annotations = persistentTypeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME); |
| |
| while(annotations.hasNext()) { |
| this.specifiedAttributeOverrides.add(buildAttributeOverride((AttributeOverrideAnnotation) annotations.next())); |
| } |
| } |
| |
| protected void initializeVirtualAttributeOverrides(JavaResourcePersistentType persistentTypeResource) { |
| for (PersistentAttribute persistentAttribute : CollectionTools.iterable(allOverridableAttributes())) { |
| JavaAttributeOverride attributeOverride = attributeOverrideNamed(persistentAttribute.getName()); |
| if (attributeOverride == null) { |
| this.virtualAttributeOverrides.add(buildVirtualAttributeOverride(persistentTypeResource, persistentAttribute)); |
| } |
| } |
| } |
| |
| protected void initializeSpecifiedAssociationOverrides(JavaResourcePersistentType resourcePersistentType) { |
| ListIterator<JavaResourceNode> annotations = resourcePersistentType.annotations(AssociationOverrideAnnotation.ANNOTATION_NAME, AssociationOverridesAnnotation.ANNOTATION_NAME); |
| |
| while(annotations.hasNext()) { |
| this.specifiedAssociationOverrides.add(buildAssociationOverride((AssociationOverrideAnnotation) annotations.next())); |
| } |
| } |
| |
| protected void initializeDefaultAssociationOverrides(JavaResourcePersistentType resourcePersistentType) { |
| for (Iterator<String> i = allOverridableAssociationNames(); i.hasNext(); ) { |
| String associationName = i.next(); |
| JavaAssociationOverride associationOverride = associationOverrideNamed(associationName); |
| if (associationOverride == null) { |
| this.virtualAssociationOverrides.add(buildAssociationOverride(new NullAssociationOverride(resourcePersistentType, associationName))); |
| } |
| } |
| } |
| |
| protected void initializeNamedQueries(JavaResourcePersistentType resourcePersistentType) { |
| ListIterator<JavaResourceNode> annotations = resourcePersistentType.annotations(NamedQueryAnnotation.ANNOTATION_NAME, NamedQueriesAnnotation.ANNOTATION_NAME); |
| |
| while(annotations.hasNext()) { |
| this.namedQueries.add(buildNamedQuery((NamedQueryAnnotation) annotations.next())); |
| } |
| } |
| |
| protected void initializeNamedNativeQueries(JavaResourcePersistentType resourcePersistentType) { |
| ListIterator<JavaResourceNode> annotations = resourcePersistentType.annotations(NamedNativeQueryAnnotation.ANNOTATION_NAME, NamedNativeQueriesAnnotation.ANNOTATION_NAME); |
| |
| while(annotations.hasNext()) { |
| this.namedNativeQueries.add(buildNamedNativeQuery((NamedNativeQueryAnnotation) annotations.next())); |
| } |
| } |
| |
| //query for the inheritance resource every time on setters. |
| //call one setter and the inheritanceResource could change. |
| //You could call more than one setter before this object has received any notification |
| //from the java resource model |
| protected InheritanceAnnotation getInheritanceResource() { |
| return (InheritanceAnnotation) this.javaResourcePersistentType.getNonNullAnnotation(InheritanceAnnotation.ANNOTATION_NAME); |
| } |
| |
| protected DiscriminatorValueAnnotation getDiscriminatorValueResource() { |
| return (DiscriminatorValueAnnotation) this.javaResourcePersistentType.getNonNullAnnotation(DiscriminatorValueAnnotation.ANNOTATION_NAME); |
| } |
| |
| protected void initializeIdClass(JavaResourcePersistentType typeResource) { |
| IdClassAnnotation idClassResource = (IdClassAnnotation) typeResource.getAnnotation(IdClassAnnotation.ANNOTATION_NAME); |
| if (idClassResource != null) { |
| this.idClass = idClassResource.getValue(); |
| } |
| } |
| |
| //****************** ITypeMapping implemenation ******************* |
| |
| public String getKey() { |
| return MappingKeys.ENTITY_TYPE_MAPPING_KEY; |
| } |
| |
| public boolean isMapped() { |
| return true; |
| } |
| |
| @Override |
| public String getTableName() { |
| return getTable().getName(); |
| } |
| |
| @Override |
| public org.eclipse.jpt.db.Table getPrimaryDbTable() { |
| return getTable().getDbTable(); |
| } |
| |
| @Override |
| public org.eclipse.jpt.db.Table getDbTable(String tableName) { |
| for (Iterator<Table> stream = this.associatedTablesIncludingInherited(); stream.hasNext();) { |
| org.eclipse.jpt.db.Table dbTable = stream.next().getDbTable(); |
| if (dbTable != null && dbTable.matchesShortJavaClassName(tableName)) { |
| return dbTable; |
| } |
| } |
| return null; |
| } |
| |
| @Override |
| public Schema getDbSchema() { |
| return getTable().getDbSchema(); |
| } |
| |
| |
| //****************** IJavaTypeMapping implemenation ******************* |
| |
| public String getAnnotationName() { |
| return EntityAnnotation.ANNOTATION_NAME; |
| } |
| |
| public Iterator<String> correspondingAnnotationNames() { |
| return new ArrayIterator<String>( |
| JPA.TABLE, |
| JPA.SECONDARY_TABLE, |
| JPA.SECONDARY_TABLES, |
| JPA.PRIMARY_KEY_JOIN_COLUMN, |
| JPA.PRIMARY_KEY_JOIN_COLUMNS, |
| JPA.ID_CLASS, |
| JPA.INHERITANCE, |
| JPA.DISCRIMINATOR_VALUE, |
| JPA.DISCRIMINATOR_COLUMN, |
| JPA.SEQUENCE_GENERATOR, |
| JPA.TABLE_GENERATOR, |
| JPA.NAMED_QUERY, |
| JPA.NAMED_QUERIES, |
| JPA.NAMED_NATIVE_QUERY, |
| JPA.NAMED_NATIVE_QUERIES, |
| JPA.SQL_RESULT_SET_MAPPING, |
| JPA.EXCLUDE_DEFAULT_LISTENERS, |
| JPA.EXCLUDE_SUPERCLASS_LISTENERS, |
| JPA.ENTITY_LISTENERS, |
| JPA.PRE_PERSIST, |
| JPA.POST_PERSIST, |
| JPA.PRE_REMOVE, |
| JPA.POST_REMOVE, |
| JPA.PRE_UPDATE, |
| JPA.POST_UPDATE, |
| JPA.POST_LOAD, |
| JPA.ATTRIBUTE_OVERRIDE, |
| JPA.ATTRIBUTE_OVERRIDES, |
| JPA.ASSOCIATION_OVERRIDE, |
| JPA.ASSOCIATION_OVERRIDES); |
| } |
| |
| //****************** IEntity implemenation ******************* |
| |
| public String getName() { |
| return (this.getSpecifiedName() == null) ? this.getDefaultName() : this.getSpecifiedName(); |
| } |
| |
| public String getSpecifiedName() { |
| return this.specifiedName; |
| } |
| |
| public void setSpecifiedName(String newSpecifiedName) { |
| String oldSpecifiedName = this.specifiedName; |
| this.specifiedName = newSpecifiedName; |
| this.entityResource.setName(newSpecifiedName); |
| firePropertyChanged(Entity.SPECIFIED_NAME_PROPERTY, oldSpecifiedName, newSpecifiedName); |
| } |
| |
| protected void setSpecifiedName_(String newSpecifiedName) { |
| String oldSpecifiedName = this.specifiedName; |
| this.specifiedName = newSpecifiedName; |
| firePropertyChanged(Entity.SPECIFIED_NAME_PROPERTY, oldSpecifiedName, newSpecifiedName); |
| } |
| |
| public String getDefaultName() { |
| return this.defaultName; |
| } |
| |
| protected/*private-protected*/ void setDefaultName(String newDefaultName) { |
| String oldDefaultName = this.defaultName; |
| this.defaultName = newDefaultName; |
| firePropertyChanged(Entity.DEFAULT_NAME_PROPERTY, oldDefaultName, newDefaultName); |
| } |
| |
| public JavaTable getTable() { |
| return this.table; |
| } |
| |
| public ListIterator<JavaSecondaryTable> specifiedSecondaryTables() { |
| return new CloneListIterator<JavaSecondaryTable>(this.specifiedSecondaryTables); |
| } |
| |
| public int specifiedSecondaryTablesSize() { |
| return this.specifiedSecondaryTables.size(); |
| } |
| |
| public JavaSecondaryTable addSpecifiedSecondaryTable(int index) { |
| JavaSecondaryTable secondaryTable = getJpaFactory().buildJavaSecondaryTable(this); |
| this.specifiedSecondaryTables.add(index, secondaryTable); |
| SecondaryTableAnnotation secondaryTableResource = (SecondaryTableAnnotation) this.javaResourcePersistentType.addAnnotation(index, SecondaryTableAnnotation.ANNOTATION_NAME, SecondaryTablesAnnotation.ANNOTATION_NAME); |
| secondaryTable.initializeFromResource(secondaryTableResource); |
| fireItemAdded(Entity.SPECIFIED_SECONDARY_TABLES_LIST, index, secondaryTable); |
| return secondaryTable; |
| } |
| |
| protected void addSpecifiedSecondaryTable(int index, JavaSecondaryTable secondaryTable) { |
| addItemToList(index, secondaryTable, this.specifiedSecondaryTables, Entity.SPECIFIED_SECONDARY_TABLES_LIST); |
| } |
| |
| public void removeSpecifiedSecondaryTable(SecondaryTable secondaryTable) { |
| this.removeSpecifiedSecondaryTable(this.specifiedSecondaryTables.indexOf(secondaryTable)); |
| } |
| |
| public void removeSpecifiedSecondaryTable(int index) { |
| JavaSecondaryTable removedSecondaryTable = this.specifiedSecondaryTables.remove(index); |
| this.javaResourcePersistentType.removeAnnotation(index, SecondaryTableAnnotation.ANNOTATION_NAME, SecondaryTablesAnnotation.ANNOTATION_NAME); |
| fireItemRemoved(Entity.SPECIFIED_SECONDARY_TABLES_LIST, index, removedSecondaryTable); |
| } |
| |
| protected void removeSpecifiedSecondaryTable_(JavaSecondaryTable secondaryTable) { |
| removeItemFromList(secondaryTable, this.specifiedSecondaryTables, Entity.SPECIFIED_SECONDARY_TABLES_LIST); |
| } |
| |
| public void moveSpecifiedSecondaryTable(int targetIndex, int sourceIndex) { |
| CollectionTools.move(this.specifiedSecondaryTables, targetIndex, sourceIndex); |
| this.javaResourcePersistentType.move(targetIndex, sourceIndex, SecondaryTablesAnnotation.ANNOTATION_NAME); |
| fireItemMoved(Entity.SPECIFIED_SECONDARY_TABLES_LIST, targetIndex, sourceIndex); |
| } |
| |
| public ListIterator<JavaSecondaryTable> secondaryTables() { |
| return specifiedSecondaryTables(); |
| } |
| |
| public int secondaryTablesSize() { |
| return specifiedSecondaryTablesSize(); |
| } |
| |
| public InheritanceType getInheritanceStrategy() { |
| return (this.getSpecifiedInheritanceStrategy() == null) ? this.getDefaultInheritanceStrategy() : this.getSpecifiedInheritanceStrategy(); |
| } |
| |
| public InheritanceType getDefaultInheritanceStrategy() { |
| return this.defaultInheritanceStrategy; |
| } |
| |
| protected void setDefaultInheritanceStrategy(InheritanceType newInheritanceType) { |
| InheritanceType oldInheritanceType = this.defaultInheritanceStrategy; |
| this.defaultInheritanceStrategy = newInheritanceType; |
| firePropertyChanged(DEFAULT_INHERITANCE_STRATEGY_PROPERTY, oldInheritanceType, newInheritanceType); |
| } |
| |
| public InheritanceType getSpecifiedInheritanceStrategy() { |
| return this.specifiedInheritanceStrategy; |
| } |
| |
| public void setSpecifiedInheritanceStrategy(InheritanceType newInheritanceType) { |
| InheritanceType oldInheritanceType = this.specifiedInheritanceStrategy; |
| this.specifiedInheritanceStrategy = newInheritanceType; |
| getInheritanceResource().setStrategy(InheritanceType.toJavaResourceModel(newInheritanceType)); |
| firePropertyChanged(SPECIFIED_INHERITANCE_STRATEGY_PROPERTY, oldInheritanceType, newInheritanceType); |
| } |
| |
| /** |
| * internal setter used only for updating from the resource model. |
| * There were problems with InvalidThreadAccess exceptions in the UI |
| * when you set a value from the UI and the annotation doesn't exist yet. |
| * Adding the annotation causes an update to occur and then the exception. |
| */ |
| protected void setSpecifiedInheritanceStrategy_(InheritanceType newInheritanceType) { |
| InheritanceType oldInheritanceType = this.specifiedInheritanceStrategy; |
| this.specifiedInheritanceStrategy = newInheritanceType; |
| firePropertyChanged(SPECIFIED_INHERITANCE_STRATEGY_PROPERTY, oldInheritanceType, newInheritanceType); |
| } |
| |
| public JavaDiscriminatorColumn getDiscriminatorColumn() { |
| return this.discriminatorColumn; |
| } |
| |
| public String getDefaultDiscriminatorValue() { |
| return this.defaultDiscriminatorValue; |
| } |
| |
| protected void setDefaultDiscriminatorValue(String newDefaultDiscriminatorValue) { |
| String oldDefaultDiscriminatorValue = this.defaultDiscriminatorValue; |
| this.defaultDiscriminatorValue = newDefaultDiscriminatorValue; |
| firePropertyChanged(DEFAULT_DISCRIMINATOR_VALUE_PROPERTY, oldDefaultDiscriminatorValue, newDefaultDiscriminatorValue); |
| } |
| |
| public String getSpecifiedDiscriminatorValue() { |
| return this.specifiedDiscriminatorValue; |
| } |
| |
| public void setSpecifiedDiscriminatorValue(String newSpecifiedDiscriminatorValue) { |
| String oldSpecifiedDiscriminatorValue = this.specifiedDiscriminatorValue; |
| this.specifiedDiscriminatorValue = newSpecifiedDiscriminatorValue; |
| getDiscriminatorValueResource().setValue(newSpecifiedDiscriminatorValue); |
| firePropertyChanged(SPECIFIED_DISCRIMINATOR_VALUE_PROPERTY, oldSpecifiedDiscriminatorValue, newSpecifiedDiscriminatorValue); |
| } |
| |
| /** |
| * internal setter used only for updating from the resource model. |
| * There were problems with InvalidThreadAccess exceptions in the UI |
| * when you set a value from the UI and the annotation doesn't exist yet. |
| * Adding the annotation causes an update to occur and then the exception. |
| */ |
| protected void setSpecifiedDiscriminatorValue_(String newSpecifiedDiscriminatorValue) { |
| String oldSpecifiedDiscriminatorValue = this.specifiedDiscriminatorValue; |
| this.specifiedDiscriminatorValue = newSpecifiedDiscriminatorValue; |
| firePropertyChanged(SPECIFIED_DISCRIMINATOR_VALUE_PROPERTY, oldSpecifiedDiscriminatorValue, newSpecifiedDiscriminatorValue); |
| } |
| |
| public String getDiscriminatorValue() { |
| return (this.getSpecifiedDiscriminatorValue() == null) ? getDefaultDiscriminatorValue() : this.getSpecifiedDiscriminatorValue(); |
| } |
| |
| public boolean isDiscriminatorValueAllowed() { |
| return this.discriminatorValueAllowed; |
| } |
| |
| protected void setDiscriminatorValueAllowed(boolean newDiscriminatorValueAllowed) { |
| boolean oldDiscriminatorValueAllowed = this.discriminatorValueAllowed; |
| this.discriminatorValueAllowed = newDiscriminatorValueAllowed; |
| firePropertyChanged(Entity.DISCRIMINATOR_VALUE_ALLOWED_PROPERTY, oldDiscriminatorValueAllowed, newDiscriminatorValueAllowed); |
| } |
| |
| public JavaTableGenerator addTableGenerator() { |
| if (getTableGenerator() != null) { |
| throw new IllegalStateException("tableGenerator already exists"); |
| } |
| this.tableGenerator = getJpaFactory().buildJavaTableGenerator(this); |
| TableGeneratorAnnotation tableGeneratorResource = (TableGeneratorAnnotation) this.javaResourcePersistentType.addAnnotation(TableGeneratorAnnotation.ANNOTATION_NAME); |
| this.tableGenerator.initializeFromResource(tableGeneratorResource); |
| firePropertyChanged(TABLE_GENERATOR_PROPERTY, null, this.tableGenerator); |
| return this.tableGenerator; |
| } |
| |
| public void removeTableGenerator() { |
| if (getTableGenerator() == null) { |
| throw new IllegalStateException("tableGenerator does not exist, cannot be removed"); |
| } |
| JavaTableGenerator oldTableGenerator = this.tableGenerator; |
| this.tableGenerator = null; |
| this.javaResourcePersistentType.removeAnnotation(TableGeneratorAnnotation.ANNOTATION_NAME); |
| firePropertyChanged(TABLE_GENERATOR_PROPERTY, oldTableGenerator, null); |
| } |
| |
| public JavaTableGenerator getTableGenerator() { |
| return this.tableGenerator; |
| } |
| |
| protected void setTableGenerator(JavaTableGenerator newTableGenerator) { |
| JavaTableGenerator oldTableGenerator = this.tableGenerator; |
| this.tableGenerator = newTableGenerator; |
| firePropertyChanged(TABLE_GENERATOR_PROPERTY, oldTableGenerator, newTableGenerator); |
| } |
| |
| public JavaSequenceGenerator addSequenceGenerator() { |
| if (getSequenceGenerator() != null) { |
| throw new IllegalStateException("sequenceGenerator already exists"); |
| } |
| this.sequenceGenerator = getJpaFactory().buildJavaSequenceGenerator(this); |
| SequenceGeneratorAnnotation sequenceGeneratorResource = (SequenceGeneratorAnnotation) this.javaResourcePersistentType.addAnnotation(SequenceGeneratorAnnotation.ANNOTATION_NAME); |
| this.sequenceGenerator.initializeFromResource(sequenceGeneratorResource); |
| firePropertyChanged(SEQUENCE_GENERATOR_PROPERTY, null, this.sequenceGenerator); |
| return this.sequenceGenerator; |
| } |
| |
| public void removeSequenceGenerator() { |
| if (getSequenceGenerator() == null) { |
| throw new IllegalStateException("sequenceGenerator does not exist, cannot be removed"); |
| } |
| JavaSequenceGenerator oldSequenceGenerator = this.sequenceGenerator; |
| this.sequenceGenerator = null; |
| this.javaResourcePersistentType.removeAnnotation(SequenceGeneratorAnnotation.ANNOTATION_NAME); |
| firePropertyChanged(SEQUENCE_GENERATOR_PROPERTY, oldSequenceGenerator,null); |
| } |
| |
| public JavaSequenceGenerator getSequenceGenerator() { |
| return this.sequenceGenerator; |
| } |
| |
| protected void setSequenceGenerator(JavaSequenceGenerator newSequenceGenerator) { |
| JavaSequenceGenerator oldSequenceGenerator = this.sequenceGenerator; |
| this.sequenceGenerator = newSequenceGenerator; |
| firePropertyChanged(SEQUENCE_GENERATOR_PROPERTY, oldSequenceGenerator, newSequenceGenerator); |
| } |
| |
| @SuppressWarnings("unchecked") |
| protected Iterator<JavaGenerator> generators() { |
| return new CompositeIterator<JavaGenerator>( |
| (getSequenceGenerator() == null) ? EmptyIterator.instance() : new SingleElementIterator(getSequenceGenerator()), |
| (getTableGenerator() == null) ? EmptyIterator.instance() : new SingleElementIterator(getTableGenerator())); |
| } |
| |
| public ListIterator<JavaPrimaryKeyJoinColumn> primaryKeyJoinColumns() { |
| return this.containsSpecifiedPrimaryKeyJoinColumns() ? this.specifiedPrimaryKeyJoinColumns() : this.defaultPrimaryKeyJoinColumns(); |
| } |
| |
| public int primaryKeyJoinColumnsSize() { |
| return this.containsSpecifiedPrimaryKeyJoinColumns() ? this.specifiedPrimaryKeyJoinColumnsSize() : this.defaultPrimaryKeyJoinColumnsSize(); |
| } |
| |
| public ListIterator<JavaPrimaryKeyJoinColumn> specifiedPrimaryKeyJoinColumns() { |
| return new CloneListIterator<JavaPrimaryKeyJoinColumn>(this.specifiedPrimaryKeyJoinColumns); |
| } |
| |
| public int specifiedPrimaryKeyJoinColumnsSize() { |
| return this.specifiedPrimaryKeyJoinColumns.size(); |
| } |
| |
| public boolean containsSpecifiedPrimaryKeyJoinColumns() { |
| return !this.specifiedPrimaryKeyJoinColumns.isEmpty(); |
| } |
| |
| public JavaPrimaryKeyJoinColumn getDefaultPrimaryKeyJoinColumn() { |
| return this.defaultPrimaryKeyJoinColumn; |
| } |
| |
| protected void setDefaultPrimaryKeyJoinColumn(JavaPrimaryKeyJoinColumn newPkJoinColumn) { |
| JavaPrimaryKeyJoinColumn oldPkJoinColumn = this.defaultPrimaryKeyJoinColumn; |
| this.defaultPrimaryKeyJoinColumn = newPkJoinColumn; |
| firePropertyChanged(Entity.DEFAULT_PRIMARY_KEY_JOIN_COLUMN, oldPkJoinColumn, newPkJoinColumn); |
| } |
| |
| protected ListIterator<JavaPrimaryKeyJoinColumn> defaultPrimaryKeyJoinColumns() { |
| if (this.defaultPrimaryKeyJoinColumn != null) { |
| return new SingleElementListIterator<JavaPrimaryKeyJoinColumn>(this.defaultPrimaryKeyJoinColumn); |
| } |
| return EmptyListIterator.instance(); |
| } |
| |
| protected int defaultPrimaryKeyJoinColumnsSize() { |
| return (this.defaultPrimaryKeyJoinColumn == null) ? 0 : 1; |
| } |
| |
| public JavaPrimaryKeyJoinColumn addSpecifiedPrimaryKeyJoinColumn(int index) { |
| JavaPrimaryKeyJoinColumn oldDefaultPkJoinColumn = this.getDefaultPrimaryKeyJoinColumn(); |
| if (oldDefaultPkJoinColumn != null) { |
| //null the default join column now if one already exists. |
| //if one does not exist, there is already a specified join column. |
| //Remove it now so that it doesn't get removed during an update and |
| //cause change notifications to be sent to the UI in the wrong order |
| this.defaultPrimaryKeyJoinColumn = null; |
| } |
| JavaPrimaryKeyJoinColumn primaryKeyJoinColumn = getJpaFactory().buildJavaPrimaryKeyJoinColumn(this, createPrimaryKeyJoinColumnOwner()); |
| this.specifiedPrimaryKeyJoinColumns.add(index, primaryKeyJoinColumn); |
| PrimaryKeyJoinColumnAnnotation pkJoinColumnResource = (PrimaryKeyJoinColumnAnnotation) this.javaResourcePersistentType.addAnnotation(index, PrimaryKeyJoinColumnAnnotation.ANNOTATION_NAME, PrimaryKeyJoinColumns.ANNOTATION_NAME); |
| primaryKeyJoinColumn.initializeFromResource(pkJoinColumnResource); |
| this.fireItemAdded(Entity.SPECIFIED_PRIMARY_KEY_JOIN_COLUMNS_LIST, index, primaryKeyJoinColumn); |
| if (oldDefaultPkJoinColumn != null) { |
| this.firePropertyChanged(Entity.DEFAULT_PRIMARY_KEY_JOIN_COLUMN, oldDefaultPkJoinColumn, null); |
| } |
| return primaryKeyJoinColumn; |
| } |
| |
| protected void addSpecifiedPrimaryKeyJoinColumn(int index, JavaPrimaryKeyJoinColumn primaryKeyJoinColumn) { |
| addItemToList(index, primaryKeyJoinColumn, this.specifiedPrimaryKeyJoinColumns, Entity.SPECIFIED_PRIMARY_KEY_JOIN_COLUMNS_LIST); |
| } |
| |
| public void removeSpecifiedPrimaryKeyJoinColumn(PrimaryKeyJoinColumn primaryKeyJoinColumn) { |
| removeSpecifiedPrimaryKeyJoinColumn(this.specifiedPrimaryKeyJoinColumns.indexOf(primaryKeyJoinColumn)); |
| } |
| |
| public void removeSpecifiedPrimaryKeyJoinColumn(int index) { |
| JavaPrimaryKeyJoinColumn removedPrimaryKeyJoinColumn = this.specifiedPrimaryKeyJoinColumns.remove(index); |
| if (!containsSpecifiedPrimaryKeyJoinColumns()) { |
| //create the defaultJoinColumn now or this will happen during project update |
| //after removing the join column from the resource model. That causes problems |
| //in the UI because the change notifications end up in the wrong order. |
| this.defaultPrimaryKeyJoinColumn = buildPrimaryKeyJoinColumn(new NullPrimaryKeyJoinColumn(this.javaResourcePersistentType)); |
| } |
| this.javaResourcePersistentType.removeAnnotation(index, PrimaryKeyJoinColumnAnnotation.ANNOTATION_NAME, PrimaryKeyJoinColumns.ANNOTATION_NAME); |
| fireItemRemoved(Entity.SPECIFIED_PRIMARY_KEY_JOIN_COLUMNS_LIST, index, removedPrimaryKeyJoinColumn); |
| if (this.defaultPrimaryKeyJoinColumn != null) { |
| //fire change notification if a defaultJoinColumn was created above |
| this.firePropertyChanged(Entity.DEFAULT_PRIMARY_KEY_JOIN_COLUMN, null, this.defaultPrimaryKeyJoinColumn); |
| } |
| } |
| |
| protected void removeSpecifiedPrimaryKeyJoinColumn_(JavaPrimaryKeyJoinColumn primaryKeyJoinColumn) { |
| removeItemFromList(primaryKeyJoinColumn, this.specifiedPrimaryKeyJoinColumns, Entity.SPECIFIED_PRIMARY_KEY_JOIN_COLUMNS_LIST); |
| } |
| |
| public void moveSpecifiedPrimaryKeyJoinColumn(int targetIndex, int sourceIndex) { |
| this.javaResourcePersistentType.move(targetIndex, sourceIndex, PrimaryKeyJoinColumns.ANNOTATION_NAME); |
| moveItemInList(targetIndex, sourceIndex, this.specifiedPrimaryKeyJoinColumns, Entity.SPECIFIED_PRIMARY_KEY_JOIN_COLUMNS_LIST); |
| } |
| |
| @SuppressWarnings("unchecked") |
| public ListIterator<JavaAttributeOverride> attributeOverrides() { |
| return new CompositeListIterator<JavaAttributeOverride>(specifiedAttributeOverrides(), virtualAttributeOverrides()); |
| } |
| |
| public int attributeOverridesSize() { |
| return this.specifiedAttributeOverridesSize() + this.virtualAttributeOverridesSize(); |
| } |
| |
| public ListIterator<JavaAttributeOverride> virtualAttributeOverrides() { |
| return new CloneListIterator<JavaAttributeOverride>(this.virtualAttributeOverrides); |
| } |
| |
| public int virtualAttributeOverridesSize() { |
| return this.virtualAttributeOverrides.size(); |
| } |
| |
| public ListIterator<JavaAttributeOverride> specifiedAttributeOverrides() { |
| return new CloneListIterator<JavaAttributeOverride>(this.specifiedAttributeOverrides); |
| } |
| |
| public int specifiedAttributeOverridesSize() { |
| return this.specifiedAttributeOverrides.size(); |
| } |
| |
| protected JavaAttributeOverride addSpecifiedAttributeOverride(int index) { |
| JavaAttributeOverride attributeOverride = getJpaFactory().buildJavaAttributeOverride(this, createAttributeOverrideOwner()); |
| this.specifiedAttributeOverrides.add(index, attributeOverride); |
| AttributeOverrideAnnotation attributeOverrideResource = (AttributeOverrideAnnotation) this.javaResourcePersistentType.addAnnotation(index, AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME); |
| attributeOverride.initializeFromResource(attributeOverrideResource); |
| this.fireItemAdded(Entity.SPECIFIED_ATTRIBUTE_OVERRIDES_LIST, index, attributeOverride); |
| return attributeOverride; |
| } |
| |
| protected JavaAttributeOverride setAttributeOverrideVirtual(boolean virtual, JavaAttributeOverride attributeOverride) { |
| // Add a new attribute override |
| if (virtual) { |
| return setAttributeOverrideVirtual(attributeOverride); |
| } |
| return setAttributeOverrideSpecified(attributeOverride); |
| } |
| |
| protected JavaAttributeOverride setAttributeOverrideVirtual(JavaAttributeOverride attributeOverride) { |
| int index = this.specifiedAttributeOverrides.indexOf(attributeOverride); |
| this.specifiedAttributeOverrides.remove(index); |
| String attributeOverrideName = attributeOverride.getName(); |
| //add the virtual attribute override so that I can control the order that change notification is sent. |
| //otherwise when we remove the annotation from java we will get an update and add the attribute override |
| //during the udpate. This causes the UI to be flaky, since change notification might not occur in the correct order |
| JavaAttributeOverride virtualAttributeOverride = null; |
| if (attributeOverrideName != null) { |
| for (PersistentAttribute persistentAttribute : CollectionTools.iterable(allOverridableAttributes())) { |
| if (persistentAttribute.getName().equals(attributeOverrideName)) { |
| //store the virtualAttributeOverride so we can fire change notification later |
| virtualAttributeOverride = buildVirtualAttributeOverride(this.javaResourcePersistentType, persistentAttribute); |
| this.virtualAttributeOverrides.add(virtualAttributeOverride); |
| break; |
| } |
| } |
| } |
| |
| this.javaResourcePersistentType.removeAnnotation(index, AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME); |
| fireItemRemoved(Entity.SPECIFIED_ATTRIBUTE_OVERRIDES_LIST, index, attributeOverride); |
| |
| if (virtualAttributeOverride != null) { |
| fireItemAdded(Entity.VIRTUAL_ATTRIBUTE_OVERRIDES_LIST, virtualAttributeOverridesSize() - 1, virtualAttributeOverride); |
| } |
| return virtualAttributeOverride; |
| } |
| |
| protected JavaAttributeOverride setAttributeOverrideSpecified(JavaAttributeOverride oldAttributeOverride) { |
| int index = specifiedAttributeOverridesSize(); |
| JavaAttributeOverride newAttributeOverride = getJpaFactory().buildJavaAttributeOverride(this, createAttributeOverrideOwner()); |
| this.specifiedAttributeOverrides.add(index, newAttributeOverride); |
| |
| AttributeOverrideAnnotation attributeOverrideResource = (AttributeOverrideAnnotation) this.javaResourcePersistentType.addAnnotation(index, AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME); |
| newAttributeOverride.initializeFromResource(attributeOverrideResource); |
| |
| int defaultIndex = this.virtualAttributeOverrides.indexOf(oldAttributeOverride); |
| this.virtualAttributeOverrides.remove(defaultIndex); |
| |
| newAttributeOverride.setName(oldAttributeOverride.getName()); |
| newAttributeOverride.getColumn().setSpecifiedName(oldAttributeOverride.getColumn().getName()); |
| |
| this.fireItemRemoved(Entity.VIRTUAL_ATTRIBUTE_OVERRIDES_LIST, defaultIndex, oldAttributeOverride); |
| this.fireItemAdded(Entity.SPECIFIED_ATTRIBUTE_OVERRIDES_LIST, index, newAttributeOverride); |
| |
| return newAttributeOverride; |
| } |
| |
| protected AttributeOverride.Owner createAttributeOverrideOwner() { |
| return new AttributeOverrideOwner(); |
| } |
| |
| protected void addSpecifiedAttributeOverride(int index, JavaAttributeOverride attributeOverride) { |
| addItemToList(index, attributeOverride, this.specifiedAttributeOverrides, Entity.SPECIFIED_ATTRIBUTE_OVERRIDES_LIST); |
| } |
| |
| protected void removeSpecifiedAttributeOverride_(JavaAttributeOverride attributeOverride) { |
| removeItemFromList(attributeOverride, this.specifiedAttributeOverrides, Entity.SPECIFIED_ATTRIBUTE_OVERRIDES_LIST); |
| } |
| |
| public void moveSpecifiedAttributeOverride(int targetIndex, int sourceIndex) { |
| CollectionTools.move(this.specifiedAttributeOverrides, targetIndex, sourceIndex); |
| this.javaResourcePersistentType.move(targetIndex, sourceIndex, AttributeOverridesAnnotation.ANNOTATION_NAME); |
| fireItemMoved(Entity.SPECIFIED_ATTRIBUTE_OVERRIDES_LIST, targetIndex, sourceIndex); |
| } |
| |
| protected void addVirtualAttributeOverride(JavaAttributeOverride attributeOverride) { |
| addItemToList(attributeOverride, this.virtualAttributeOverrides, Entity.VIRTUAL_ATTRIBUTE_OVERRIDES_LIST); |
| } |
| |
| protected void removeVirtualAttributeOverride(JavaAttributeOverride attributeOverride) { |
| removeItemFromList(attributeOverride, this.virtualAttributeOverrides, Entity.VIRTUAL_ATTRIBUTE_OVERRIDES_LIST); |
| } |
| |
| public JavaAttributeOverride attributeOverrideNamed(String name) { |
| return (JavaAttributeOverride) overrideNamed(name, attributeOverrides()); |
| } |
| |
| public boolean containsAttributeOverride(String name) { |
| return containsOverride(name, attributeOverrides()); |
| } |
| |
| public boolean containsDefaultAttributeOverride(String name) { |
| return containsOverride(name, virtualAttributeOverrides()); |
| } |
| |
| public boolean containsSpecifiedAttributeOverride(String name) { |
| return containsOverride(name, specifiedAttributeOverrides()); |
| } |
| |
| public JavaAssociationOverride associationOverrideNamed(String name) { |
| return (JavaAssociationOverride) overrideNamed(name, associationOverrides()); |
| } |
| |
| public boolean containsAssociationOverride(String name) { |
| return containsOverride(name, associationOverrides()); |
| } |
| |
| public boolean containsSpecifiedAssociationOverride(String name) { |
| return containsOverride(name, specifiedAssociationOverrides()); |
| } |
| |
| public boolean containsDefaultAssociationOverride(String name) { |
| return containsOverride(name, virtualAssociationOverrides()); |
| } |
| |
| private BaseOverride overrideNamed(String name, ListIterator<? extends BaseOverride> overrides) { |
| for (BaseOverride override : CollectionTools.iterable(overrides)) { |
| String overrideName = override.getName(); |
| if (overrideName == null && name == null) { |
| return override; |
| } |
| if (overrideName != null && overrideName.equals(name)) { |
| return override; |
| } |
| } |
| return null; |
| } |
| |
| private boolean containsOverride(String name, ListIterator<? extends BaseOverride> overrides) { |
| return overrideNamed(name, overrides) != null; |
| } |
| |
| |
| @SuppressWarnings("unchecked") |
| public ListIterator<JavaAssociationOverride> associationOverrides() { |
| return new CompositeListIterator<JavaAssociationOverride>(specifiedAssociationOverrides(), virtualAssociationOverrides()); |
| } |
| |
| public int associationOverridesSize() { |
| return this.specifiedAssociationOverridesSize() + this.virtualAssociationOverridesSize(); |
| } |
| |
| public ListIterator<JavaAssociationOverride> virtualAssociationOverrides() { |
| return new CloneListIterator<JavaAssociationOverride>(this.virtualAssociationOverrides); |
| } |
| |
| public int virtualAssociationOverridesSize() { |
| return this.virtualAssociationOverrides.size(); |
| } |
| |
| public ListIterator<JavaAssociationOverride> specifiedAssociationOverrides() { |
| return new CloneListIterator<JavaAssociationOverride>(this.specifiedAssociationOverrides); |
| } |
| |
| public int specifiedAssociationOverridesSize() { |
| return this.specifiedAssociationOverrides.size(); |
| } |
| |
| public JavaAssociationOverride addSpecifiedAssociationOverride(int index) { |
| JavaAssociationOverride associationOverride = getJpaFactory().buildJavaAssociationOverride(this, createAssociationOverrideOwner()); |
| this.specifiedAssociationOverrides.add(index, associationOverride); |
| AssociationOverrideAnnotation associationOverrideResource = (AssociationOverrideAnnotation) this.javaResourcePersistentType.addAnnotation(index, AssociationOverrideAnnotation.ANNOTATION_NAME, AssociationOverridesAnnotation.ANNOTATION_NAME); |
| associationOverride.initializeFromResource(associationOverrideResource); |
| this.fireItemAdded(Entity.SPECIFIED_ASSOCIATION_OVERRIDES_LIST, index, associationOverride); |
| return associationOverride; |
| } |
| |
| protected AssociationOverride.Owner createAssociationOverrideOwner() { |
| return new AssociationOverrideOwner(); |
| } |
| |
| protected void addSpecifiedAssociationOverride(int index, JavaAssociationOverride associationOverride) { |
| addItemToList(index, associationOverride, this.specifiedAssociationOverrides, Entity.SPECIFIED_ASSOCIATION_OVERRIDES_LIST); |
| } |
| |
| protected void removeSpecifiedAssociationOverride_(JavaAssociationOverride associationOverride) { |
| removeItemFromList(associationOverride, this.specifiedAssociationOverrides, Entity.SPECIFIED_ASSOCIATION_OVERRIDES_LIST); |
| } |
| |
| public void moveSpecifiedAssociationOverride(int targetIndex, int sourceIndex) { |
| CollectionTools.move(this.specifiedAssociationOverrides, targetIndex, sourceIndex); |
| this.javaResourcePersistentType.move(targetIndex, sourceIndex, AssociationOverridesAnnotation.ANNOTATION_NAME); |
| fireItemMoved(Entity.SPECIFIED_ASSOCIATION_OVERRIDES_LIST, targetIndex, sourceIndex); |
| } |
| |
| protected JavaAssociationOverride setAssociationOverrideVirtual(boolean virtual, JavaAssociationOverride associationOverride) { |
| // Add a new attribute override |
| if (virtual) { |
| return setAssociationOverrideVirtual(associationOverride); |
| } |
| return setAssociationOverrideSpecified(associationOverride); |
| } |
| |
| protected JavaAssociationOverride setAssociationOverrideVirtual(JavaAssociationOverride associationOverride) { |
| int index = this.specifiedAssociationOverrides.indexOf(associationOverride); |
| this.specifiedAssociationOverrides.remove(index); |
| String associationOverrideName = associationOverride.getName(); |
| //add the virtual attribute override so that I can control the order that change notification is sent. |
| //otherwise when we remove the annotation from java we will get an update and add the attribute override |
| //during the udpate. This causes the UI to be flaky, since change notification might not occur in the correct order |
| JavaAssociationOverride virtualAssociationOverride = null; |
| if (associationOverrideName != null) { |
| for (PersistentAttribute persistentAttribute : CollectionTools.iterable(allOverridableAssociations())) { |
| if (persistentAttribute.getName().equals(associationOverrideName)) { |
| //store the virtualAssociationOverride so we can fire change notification later |
| virtualAssociationOverride = buildAssociationOverride(new NullAssociationOverride(this.javaResourcePersistentType, associationOverrideName)); |
| this.virtualAssociationOverrides.add(virtualAssociationOverride); |
| break; |
| } |
| } |
| } |
| |
| this.javaResourcePersistentType.removeAnnotation(index, AssociationOverrideAnnotation.ANNOTATION_NAME, AssociationOverridesAnnotation.ANNOTATION_NAME); |
| fireItemRemoved(Entity.SPECIFIED_ASSOCIATION_OVERRIDES_LIST, index, associationOverride); |
| |
| if (virtualAssociationOverride != null) { |
| fireItemAdded(Entity.VIRTUAL_ASSOCIATION_OVERRIDES_LIST, virtualAssociationOverridesSize() - 1, virtualAssociationOverride); |
| } |
| return virtualAssociationOverride; |
| } |
| |
| protected JavaAssociationOverride setAssociationOverrideSpecified(JavaAssociationOverride oldAssociationOverride) { |
| int index = specifiedAssociationOverridesSize(); |
| JavaAssociationOverride newAssociationOverride = getJpaFactory().buildJavaAssociationOverride(this, createAssociationOverrideOwner()); |
| this.specifiedAssociationOverrides.add(index, newAssociationOverride); |
| |
| AssociationOverrideAnnotation attributeOverrideResource = (AssociationOverrideAnnotation) this.javaResourcePersistentType.addAnnotation(index, AssociationOverrideAnnotation.ANNOTATION_NAME, AssociationOverridesAnnotation.ANNOTATION_NAME); |
| newAssociationOverride.initializeFromResource(attributeOverrideResource); |
| |
| int virtualIndex = this.virtualAssociationOverrides.indexOf(oldAssociationOverride); |
| this.virtualAssociationOverrides.remove(virtualIndex); |
| |
| newAssociationOverride.setName(oldAssociationOverride.getName()); |
| |
| this.fireItemRemoved(Entity.VIRTUAL_ASSOCIATION_OVERRIDES_LIST, virtualIndex, oldAssociationOverride); |
| this.fireItemAdded(Entity.SPECIFIED_ASSOCIATION_OVERRIDES_LIST, index, newAssociationOverride); |
| |
| return newAssociationOverride; |
| } |
| |
| protected void addVirtualAssociationOverride(JavaAssociationOverride associationOverride) { |
| addItemToList(associationOverride, this.virtualAssociationOverrides, Entity.VIRTUAL_ASSOCIATION_OVERRIDES_LIST); |
| } |
| |
| protected void removeVirtualAssociationOverride(JavaAssociationOverride associationOverride) { |
| removeItemFromList(associationOverride, this.virtualAssociationOverrides, Entity.VIRTUAL_ASSOCIATION_OVERRIDES_LIST); |
| } |
| |
| public ListIterator<JavaNamedQuery> namedQueries() { |
| return new CloneListIterator<JavaNamedQuery>(this.namedQueries); |
| } |
| |
| public int namedQueriesSize() { |
| return this.namedQueries.size(); |
| } |
| |
| public JavaNamedQuery addNamedQuery(int index) { |
| JavaNamedQuery namedQuery = getJpaFactory().buildJavaNamedQuery(this); |
| this.namedQueries.add(index, namedQuery); |
| NamedQueryAnnotation namedQueryAnnotation = (NamedQueryAnnotation) this.javaResourcePersistentType.addAnnotation(index, NamedQueryAnnotation.ANNOTATION_NAME, NamedQueriesAnnotation.ANNOTATION_NAME); |
| namedQuery.initializeFromResource(namedQueryAnnotation); |
| fireItemAdded(QueryHolder.NAMED_QUERIES_LIST, index, namedQuery); |
| return namedQuery; |
| } |
| |
| protected void addNamedQuery(int index, JavaNamedQuery namedQuery) { |
| addItemToList(index, namedQuery, this.namedQueries, QueryHolder.NAMED_QUERIES_LIST); |
| } |
| |
| public void removeNamedQuery(NamedQuery namedQuery) { |
| removeNamedQuery(this.namedQueries.indexOf(namedQuery)); |
| } |
| |
| public void removeNamedQuery(int index) { |
| JavaNamedQuery removedNamedQuery = this.namedQueries.remove(index); |
| this.javaResourcePersistentType.removeAnnotation(index, NamedQueryAnnotation.ANNOTATION_NAME, NamedQueriesAnnotation.ANNOTATION_NAME); |
| fireItemRemoved(QueryHolder.NAMED_QUERIES_LIST, index, removedNamedQuery); |
| } |
| |
| protected void removeNamedQuery_(JavaNamedQuery namedQuery) { |
| removeItemFromList(namedQuery, this.namedQueries, QueryHolder.NAMED_QUERIES_LIST); |
| } |
| |
| public void moveNamedQuery(int targetIndex, int sourceIndex) { |
| CollectionTools.move(this.namedQueries, targetIndex, sourceIndex); |
| this.javaResourcePersistentType.move(targetIndex, sourceIndex, NamedQueriesAnnotation.ANNOTATION_NAME); |
| fireItemMoved(QueryHolder.NAMED_QUERIES_LIST, targetIndex, sourceIndex); |
| } |
| |
| public ListIterator<JavaNamedNativeQuery> namedNativeQueries() { |
| return new CloneListIterator<JavaNamedNativeQuery>(this.namedNativeQueries); |
| } |
| |
| public int namedNativeQueriesSize() { |
| return this.namedNativeQueries.size(); |
| } |
| |
| public JavaNamedNativeQuery addNamedNativeQuery(int index) { |
| JavaNamedNativeQuery namedNativeQuery = getJpaFactory().buildJavaNamedNativeQuery(this); |
| this.namedNativeQueries.add(index, namedNativeQuery); |
| NamedNativeQueryAnnotation namedNativeQueryAnnotation = (NamedNativeQueryAnnotation) this.javaResourcePersistentType.addAnnotation(index, NamedNativeQueryAnnotation.ANNOTATION_NAME, NamedNativeQueriesAnnotation.ANNOTATION_NAME); |
| namedNativeQuery.initializeFromResource(namedNativeQueryAnnotation); |
| fireItemAdded(QueryHolder.NAMED_NATIVE_QUERIES_LIST, index, namedNativeQuery); |
| return namedNativeQuery; |
| } |
| |
| protected void addNamedNativeQuery(int index, JavaNamedNativeQuery namedNativeQuery) { |
| addItemToList(index, namedNativeQuery, this.namedNativeQueries, QueryHolder.NAMED_NATIVE_QUERIES_LIST); |
| } |
| |
| public void removeNamedNativeQuery(NamedNativeQuery namedNativeQuery) { |
| this.removeNamedNativeQuery(this.namedNativeQueries.indexOf(namedNativeQuery)); |
| } |
| |
| public void removeNamedNativeQuery(int index) { |
| JavaNamedNativeQuery removedNamedNativeQuery = this.namedNativeQueries.remove(index); |
| this.javaResourcePersistentType.removeAnnotation(index, NamedNativeQueryAnnotation.ANNOTATION_NAME, NamedNativeQueriesAnnotation.ANNOTATION_NAME); |
| fireItemRemoved(QueryHolder.NAMED_NATIVE_QUERIES_LIST, index, removedNamedNativeQuery); |
| } |
| |
| protected void removeNamedNativeQuery_(JavaNamedNativeQuery namedNativeQuery) { |
| removeItemFromList(namedNativeQuery, this.namedNativeQueries, QueryHolder.NAMED_NATIVE_QUERIES_LIST); |
| } |
| |
| public void moveNamedNativeQuery(int targetIndex, int sourceIndex) { |
| CollectionTools.move(this.namedNativeQueries, targetIndex, sourceIndex); |
| this.javaResourcePersistentType.move(targetIndex, sourceIndex, NamedNativeQueriesAnnotation.ANNOTATION_NAME); |
| fireItemMoved(QueryHolder.NAMED_NATIVE_QUERIES_LIST, targetIndex, sourceIndex); |
| } |
| |
| @SuppressWarnings("unchecked") |
| protected Iterator<JavaQuery> queries() { |
| return new CompositeIterator<JavaQuery>(this.namedNativeQueries(), this.namedQueries()); |
| } |
| |
| public String getIdClass() { |
| return this.idClass; |
| } |
| |
| public void setIdClass(String newIdClass) { |
| String oldIdClass = this.idClass; |
| this.idClass = newIdClass; |
| if (newIdClass != oldIdClass) { |
| if (newIdClass != null) { |
| if (getIdClassResource() == null) { |
| addIdClassResource(); |
| } |
| getIdClassResource().setValue(newIdClass); |
| } |
| else { |
| removeIdClassResource(); |
| } |
| } |
| firePropertyChanged(IdClass.ID_CLASS_PROPERTY, oldIdClass, newIdClass); |
| } |
| |
| protected void setIdClass_(String newIdClass) { |
| String oldIdClass = this.idClass; |
| this.idClass = newIdClass; |
| firePropertyChanged(IdClass.ID_CLASS_PROPERTY, oldIdClass, newIdClass); |
| } |
| |
| protected IdClassAnnotation getIdClassResource() { |
| return (IdClassAnnotation) this.javaResourcePersistentType.getAnnotation(IdClassAnnotation.ANNOTATION_NAME); |
| } |
| |
| protected void addIdClassResource() { |
| this.javaResourcePersistentType.addAnnotation(IdClassAnnotation.ANNOTATION_NAME); |
| } |
| |
| protected void removeIdClassResource() { |
| this.javaResourcePersistentType.removeAnnotation(IdClassAnnotation.ANNOTATION_NAME); |
| } |
| |
| public Entity getParentEntity() { |
| for (Iterator<PersistentType> i = getPersistentType().inheritanceHierarchy(); i.hasNext();) { |
| TypeMapping typeMapping = i.next().getMapping(); |
| if (typeMapping != this && typeMapping instanceof Entity) { |
| return (Entity) typeMapping; |
| } |
| } |
| return this; |
| } |
| |
| public Entity getRootEntity() { |
| Entity rootEntity = this; |
| for (Iterator<PersistentType> i = getPersistentType().inheritanceHierarchy(); i.hasNext();) { |
| PersistentType persistentType = i.next(); |
| if (persistentType.getMapping() instanceof Entity) { |
| rootEntity = (Entity) persistentType.getMapping(); |
| } |
| } |
| return rootEntity; |
| } |
| |
| public String getPrimaryKeyColumnName() { |
| return primaryKeyColumnName(getPersistentType().allAttributes()); |
| } |
| |
| public static String primaryKeyColumnName(Iterator<PersistentAttribute> attributes) { |
| String pkColumnName = null; |
| for (Iterator<PersistentAttribute> stream = attributes; stream.hasNext();) { |
| PersistentAttribute attribute = stream.next(); |
| String name = attribute.getPrimaryKeyColumnName(); |
| if (pkColumnName == null) { |
| pkColumnName = name; |
| } |
| else if (name != null) { |
| // if we encounter a composite primary key, return null |
| return null; |
| } |
| } |
| // if we encounter only a single primary key column name, return it |
| return pkColumnName; |
| |
| } |
| |
| @Override |
| public boolean tableNameIsInvalid(String tableName) { |
| return !CollectionTools.contains(this.associatedTableNamesIncludingInherited(), tableName); |
| } |
| |
| @Override |
| public Iterator<Table> associatedTables() { |
| return new CompositeIterator<Table>(this.getTable(), this.secondaryTables()); |
| } |
| |
| @Override |
| public Iterator<Table> associatedTablesIncludingInherited() { |
| return new CompositeIterator<Table>(new TransformationIterator<TypeMapping, Iterator<Table>>(this.inheritanceHierarchy()) { |
| @Override |
| protected Iterator<Table> transform(TypeMapping mapping) { |
| return new FilteringIterator<Table, Table>(mapping.associatedTables()) { |
| @Override |
| protected boolean accept(Table o) { |
| return true; |
| //TODO |
| //filtering these out so as to avoid the duplicate table, root and children share the same table |
| //return !(o instanceof SingleTableInheritanceChildTableImpl); |
| } |
| }; |
| } |
| }); |
| } |
| |
| @Override |
| public Iterator<String> associatedTableNamesIncludingInherited() { |
| return this.nonNullTableNames(this.associatedTablesIncludingInherited()); |
| } |
| |
| protected Iterator<String> nonNullTableNames(Iterator<Table> tables) { |
| return new FilteringIterator<String, String>(this.tableNames(tables)) { |
| @Override |
| protected boolean accept(String o) { |
| return o != null; |
| } |
| }; |
| } |
| |
| protected Iterator<String> tableNames(Iterator<Table> tables) { |
| return new TransformationIterator<Table, String>(tables) { |
| @Override |
| protected String transform(Table t) { |
| return t.getName(); |
| } |
| }; |
| } |
| |
| /** |
| * Return an iterator of Entities, each which inherits from the one before, |
| * and terminates at the root entity (or at the point of cyclicity). |
| */ |
| protected Iterator<TypeMapping> inheritanceHierarchy() { |
| return new TransformationIterator<PersistentType, TypeMapping>(getPersistentType().inheritanceHierarchy()) { |
| @Override |
| protected TypeMapping transform(PersistentType type) { |
| return type.getMapping(); |
| } |
| }; |
| } |
| |
| @Override |
| public Iterator<String> allOverridableAttributeNames() { |
| return new CompositeIterator<String>(new TransformationIterator<TypeMapping, Iterator<String>>(this.inheritanceHierarchy()) { |
| @Override |
| protected Iterator<String> transform(TypeMapping mapping) { |
| return mapping.overridableAttributeNames(); |
| } |
| }); |
| } |
| |
| |
| @Override |
| public Iterator<PersistentAttribute> allOverridableAttributes() { |
| return new CompositeIterator<PersistentAttribute>(new TransformationIterator<TypeMapping, Iterator<PersistentAttribute>>(this.inheritanceHierarchy()) { |
| @Override |
| protected Iterator<PersistentAttribute> transform(TypeMapping mapping) { |
| return mapping.overridableAttributes(); |
| } |
| }); |
| } |
| |
| @Override |
| public Iterator<PersistentAttribute> allOverridableAssociations() { |
| return new CompositeIterator<PersistentAttribute>(new TransformationIterator<TypeMapping, Iterator<PersistentAttribute>>(this.inheritanceHierarchy()) { |
| @Override |
| protected Iterator<PersistentAttribute> transform(TypeMapping mapping) { |
| return mapping.overridableAssociations(); |
| } |
| }); |
| } |
| |
| @Override |
| public Iterator<String> allOverridableAssociationNames() { |
| return new CompositeIterator<String>(new TransformationIterator<TypeMapping, Iterator<String>>(this.inheritanceHierarchy()) { |
| @Override |
| protected Iterator<String> transform(TypeMapping mapping) { |
| return mapping.overridableAssociationNames(); |
| } |
| }); |
| } |
| |
| @Override |
| public void update(JavaResourcePersistentType resourcePersistentType) { |
| super.update(resourcePersistentType); |
| this.entityResource = (EntityAnnotation) resourcePersistentType.getMappingAnnotation(EntityAnnotation.ANNOTATION_NAME); |
| |
| this.setSpecifiedName_(this.specifiedName(this.entityResource)); |
| this.setDefaultName(this.defaultName(resourcePersistentType)); |
| |
| this.updateInheritance(getInheritanceResource()); |
| this.updateDiscriminatorColumn(resourcePersistentType); |
| this.updateDiscriminatorValue(getDiscriminatorValueResource()); |
| this.setDiscriminatorValueAllowed(discriminatorValueIsAllowed(resourcePersistentType)); |
| this.updateTable(resourcePersistentType); |
| this.updateSecondaryTables(resourcePersistentType); |
| this.updateTableGenerator(resourcePersistentType); |
| this.updateSequenceGenerator(resourcePersistentType); |
| this.updateSpecifiedPrimaryKeyJoinColumns(resourcePersistentType); |
| this.updateDefaultPrimaryKeyJoinColumn(resourcePersistentType); |
| this.updateSpecifiedAttributeOverrides(resourcePersistentType); |
| this.updateVirtualAttributeOverrides(resourcePersistentType); |
| this.updateSpecifiedAssociationOverrides(resourcePersistentType); |
| this.updateVirtualAssociationOverrides(resourcePersistentType); |
| this.updateNamedQueries(resourcePersistentType); |
| this.updateNamedNativeQueries(resourcePersistentType); |
| this.updateIdClass(resourcePersistentType); |
| this.updatePersistenceUnitGeneratorsAndQueries(); |
| } |
| |
| protected String specifiedName(EntityAnnotation entityResource) { |
| return entityResource.getName(); |
| } |
| |
| protected String defaultName(JavaResourcePersistentType persistentTypeResource) { |
| return persistentTypeResource.getName(); |
| } |
| |
| protected void updateTable(JavaResourcePersistentType persistentTypeResource) { |
| getTable().update(persistentTypeResource); |
| } |
| |
| protected void updateInheritance(InheritanceAnnotation inheritanceResource) { |
| this.setSpecifiedInheritanceStrategy_(this.specifiedInheritanceStrategy(inheritanceResource)); |
| this.setDefaultInheritanceStrategy(this.defaultInheritanceStrategy()); |
| } |
| |
| protected InheritanceType specifiedInheritanceStrategy(InheritanceAnnotation inheritanceResource) { |
| return InheritanceType.fromJavaResourceModel(inheritanceResource.getStrategy()); |
| } |
| |
| protected InheritanceType defaultInheritanceStrategy() { |
| if (getRootEntity() == this) { |
| return InheritanceType.SINGLE_TABLE; |
| } |
| return getRootEntity().getInheritanceStrategy(); |
| } |
| |
| protected void updateDiscriminatorColumn(JavaResourcePersistentType persistentTypeResource) { |
| getDiscriminatorColumn().update(persistentTypeResource); |
| } |
| |
| protected void updateDiscriminatorValue(DiscriminatorValueAnnotation discriminatorValueResource) { |
| this.setSpecifiedDiscriminatorValue_(discriminatorValueResource.getValue()); |
| this.setDefaultDiscriminatorValue(this.javaDefaultDiscriminatorValue()); |
| } |
| |
| /** |
| * From the Spec: |
| * If the DiscriminatorValue annotation is not specified, a |
| * provider-specific function to generate a value representing |
| * the entity type is used for the value of the discriminator |
| * column. If the DiscriminatorType is STRING, the discriminator |
| * value default is the entity name. |
| * |
| * TODO extension point for provider-specific function? |
| */ |
| protected String javaDefaultDiscriminatorValue() { |
| if (this.javaResourcePersistentType.isAbstract()) { |
| return null; |
| } |
| if (this.getDiscriminatorType() != DiscriminatorType.STRING) { |
| return null; |
| } |
| return this.getName(); |
| } |
| |
| protected DiscriminatorType getDiscriminatorType() { |
| return this.getDiscriminatorColumn().getDiscriminatorType(); |
| } |
| |
| protected boolean discriminatorValueIsAllowed(JavaResourcePersistentType persistentTypeResource) { |
| return !persistentTypeResource.isAbstract(); |
| } |
| |
| protected void updateSecondaryTables(JavaResourcePersistentType persistentTypeResource) { |
| ListIterator<JavaSecondaryTable> secondaryTables = specifiedSecondaryTables(); |
| ListIterator<JavaResourceNode> resourceSecondaryTables = persistentTypeResource.annotations(SecondaryTableAnnotation.ANNOTATION_NAME, SecondaryTablesAnnotation.ANNOTATION_NAME); |
| |
| while (secondaryTables.hasNext()) { |
| JavaSecondaryTable secondaryTable = secondaryTables.next(); |
| if (resourceSecondaryTables.hasNext()) { |
| secondaryTable.update((SecondaryTableAnnotation) resourceSecondaryTables.next()); |
| } |
| else { |
| removeSpecifiedSecondaryTable_(secondaryTable); |
| } |
| } |
| |
| while (resourceSecondaryTables.hasNext()) { |
| addSpecifiedSecondaryTable(specifiedSecondaryTablesSize(), buildSecondaryTable((SecondaryTableAnnotation) resourceSecondaryTables.next())); |
| } |
| } |
| |
| protected JavaSecondaryTable buildSecondaryTable(SecondaryTableAnnotation secondaryTableResource) { |
| JavaSecondaryTable secondaryTable = getJpaFactory().buildJavaSecondaryTable(this); |
| secondaryTable.initializeFromResource(secondaryTableResource); |
| return secondaryTable; |
| } |
| |
| protected void updateTableGenerator(JavaResourcePersistentType persistentTypeResource) { |
| TableGeneratorAnnotation tableGeneratorResource = tableGenerator(persistentTypeResource); |
| if (tableGeneratorResource == null) { |
| if (getTableGenerator() != null) { |
| setTableGenerator(null); |
| } |
| } |
| else { |
| if (getTableGenerator() == null) { |
| setTableGenerator(buildTableGenerator(tableGeneratorResource)); |
| } |
| else { |
| getTableGenerator().update(tableGeneratorResource); |
| } |
| } |
| } |
| |
| protected JavaTableGenerator buildTableGenerator(TableGeneratorAnnotation tableGeneratorResource) { |
| JavaTableGenerator tableGenerator = getJpaFactory().buildJavaTableGenerator(this); |
| tableGenerator.initializeFromResource(tableGeneratorResource); |
| return tableGenerator; |
| } |
| |
| protected TableGeneratorAnnotation tableGenerator(JavaResourcePersistentType persistentTypeResource) { |
| return (TableGeneratorAnnotation) persistentTypeResource.getAnnotation(TableGeneratorAnnotation.ANNOTATION_NAME); |
| } |
| |
| protected void updateSequenceGenerator(JavaResourcePersistentType persistentTypeResource) { |
| SequenceGeneratorAnnotation sequenceGeneratorResource = sequenceGenerator(persistentTypeResource); |
| if (sequenceGeneratorResource == null) { |
| if (getSequenceGenerator() != null) { |
| setSequenceGenerator(null); |
| } |
| } |
| else { |
| if (getSequenceGenerator() == null) { |
| setSequenceGenerator(buildSequenceGenerator(sequenceGeneratorResource)); |
| } |
| else { |
| getSequenceGenerator().update(sequenceGeneratorResource); |
| } |
| } |
| } |
| |
| protected JavaSequenceGenerator buildSequenceGenerator(SequenceGeneratorAnnotation sequenceGeneratorResource) { |
| JavaSequenceGenerator sequenceGenerator = getJpaFactory().buildJavaSequenceGenerator(this); |
| sequenceGenerator.initializeFromResource(sequenceGeneratorResource); |
| return sequenceGenerator; |
| } |
| |
| protected SequenceGeneratorAnnotation sequenceGenerator(JavaResourcePersistentType persistentTypeResource) { |
| return (SequenceGeneratorAnnotation) persistentTypeResource.getAnnotation(SequenceGeneratorAnnotation.ANNOTATION_NAME); |
| } |
| |
| |
| protected void updateSpecifiedPrimaryKeyJoinColumns(JavaResourcePersistentType persistentTypeResource) { |
| ListIterator<JavaPrimaryKeyJoinColumn> primaryKeyJoinColumns = specifiedPrimaryKeyJoinColumns(); |
| ListIterator<JavaResourceNode> resourcePrimaryKeyJoinColumns = persistentTypeResource.annotations(PrimaryKeyJoinColumnAnnotation.ANNOTATION_NAME, PrimaryKeyJoinColumns.ANNOTATION_NAME); |
| |
| while (primaryKeyJoinColumns.hasNext()) { |
| JavaPrimaryKeyJoinColumn primaryKeyJoinColumn = primaryKeyJoinColumns.next(); |
| if (resourcePrimaryKeyJoinColumns.hasNext()) { |
| primaryKeyJoinColumn.update((PrimaryKeyJoinColumnAnnotation) resourcePrimaryKeyJoinColumns.next()); |
| } |
| else { |
| removeSpecifiedPrimaryKeyJoinColumn_(primaryKeyJoinColumn); |
| } |
| } |
| |
| while (resourcePrimaryKeyJoinColumns.hasNext()) { |
| addSpecifiedPrimaryKeyJoinColumn(specifiedPrimaryKeyJoinColumnsSize(), buildPrimaryKeyJoinColumn((PrimaryKeyJoinColumnAnnotation) resourcePrimaryKeyJoinColumns.next())); |
| } |
| } |
| |
| protected JavaPrimaryKeyJoinColumn buildPrimaryKeyJoinColumn(PrimaryKeyJoinColumnAnnotation primaryKeyJoinColumnResource) { |
| JavaPrimaryKeyJoinColumn primaryKeyJoinColumn = getJpaFactory().buildJavaPrimaryKeyJoinColumn(this, createPrimaryKeyJoinColumnOwner()); |
| primaryKeyJoinColumn.initializeFromResource(primaryKeyJoinColumnResource); |
| return primaryKeyJoinColumn; |
| } |
| |
| protected void updateDefaultPrimaryKeyJoinColumn(JavaResourcePersistentType persistentTypeResource) { |
| if (!shouldBuildDefaultPrimaryKeyJoinColumn()) { |
| setDefaultPrimaryKeyJoinColumn(null); |
| return; |
| } |
| if (getDefaultPrimaryKeyJoinColumn() == null) { |
| this.setDefaultPrimaryKeyJoinColumn(buildPrimaryKeyJoinColumn(new NullPrimaryKeyJoinColumn(this.javaResourcePersistentType))); |
| } |
| else { |
| this.defaultPrimaryKeyJoinColumn.update(new NullPrimaryKeyJoinColumn(persistentTypeResource)); |
| } |
| } |
| |
| protected void updateSpecifiedAttributeOverrides(JavaResourcePersistentType persistentTypeResource) { |
| ListIterator<JavaAttributeOverride> attributeOverrides = specifiedAttributeOverrides(); |
| ListIterator<JavaResourceNode> resourceAttributeOverrides = persistentTypeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME); |
| |
| while (attributeOverrides.hasNext()) { |
| JavaAttributeOverride attributeOverride = attributeOverrides.next(); |
| if (resourceAttributeOverrides.hasNext()) { |
| attributeOverride.update((AttributeOverrideAnnotation) resourceAttributeOverrides.next()); |
| } |
| else { |
| removeSpecifiedAttributeOverride_(attributeOverride); |
| } |
| } |
| |
| while (resourceAttributeOverrides.hasNext()) { |
| addSpecifiedAttributeOverride(specifiedAttributeOverridesSize(), buildAttributeOverride((AttributeOverrideAnnotation) resourceAttributeOverrides.next())); |
| } |
| } |
| |
| protected JavaAttributeOverride buildAttributeOverride(AttributeOverrideAnnotation attributeOverrideResource) { |
| JavaAttributeOverride attributeOverride = getJpaFactory().buildJavaAttributeOverride(this, createAttributeOverrideOwner()); |
| attributeOverride.initializeFromResource(attributeOverrideResource); |
| return attributeOverride; |
| } |
| |
| protected JavaAttributeOverride buildVirtualAttributeOverride(JavaResourcePersistentType resourcePersistentType, PersistentAttribute attribute) { |
| return buildAttributeOverride(buildVirtualAttributeOverrideResource(resourcePersistentType, attribute)); |
| } |
| |
| protected VirtualAttributeOverride buildVirtualAttributeOverrideResource(JavaResourcePersistentType resourcePersistentType, PersistentAttribute attribute) { |
| ColumnMapping columnMapping = (ColumnMapping) attribute.getMapping(); |
| return new VirtualAttributeOverride(resourcePersistentType, attribute.getName(), columnMapping.getColumn()); |
| } |
| |
| protected void updateVirtualAttributeOverrides(JavaResourcePersistentType resourcePersistentType) { |
| for (PersistentAttribute persistentAttribute : CollectionTools.iterable(allOverridableAttributes())) { |
| JavaAttributeOverride attributeOverride = attributeOverrideNamed(persistentAttribute.getName()); |
| if (attributeOverride == null) { |
| addVirtualAttributeOverride(buildVirtualAttributeOverride(resourcePersistentType, persistentAttribute)); |
| } |
| else if (attributeOverride.isVirtual()) { |
| attributeOverride.update(buildVirtualAttributeOverrideResource(resourcePersistentType, persistentAttribute)); |
| } |
| } |
| |
| Collection<String> attributeNames = CollectionTools.collection(allOverridableAttributeNames()); |
| |
| //remove any default mappings that are not included in the attributeNames collection |
| for (JavaAttributeOverride attributeOverride : CollectionTools.iterable(virtualAttributeOverrides())) { |
| if (!attributeNames.contains(attributeOverride.getName()) |
| || containsSpecifiedAttributeOverride(attributeOverride.getName())) { |
| removeVirtualAttributeOverride(attributeOverride); |
| } |
| } |
| } |
| |
| protected void updateSpecifiedAssociationOverrides(JavaResourcePersistentType resourcePersistentType) { |
| ListIterator<JavaAssociationOverride> associationOverrides = specifiedAssociationOverrides(); |
| ListIterator<JavaResourceNode> resourceAssociationOverrides = resourcePersistentType.annotations(AssociationOverrideAnnotation.ANNOTATION_NAME, AssociationOverridesAnnotation.ANNOTATION_NAME); |
| |
| while (associationOverrides.hasNext()) { |
| JavaAssociationOverride associationOverride = associationOverrides.next(); |
| if (resourceAssociationOverrides.hasNext()) { |
| associationOverride.update((AssociationOverrideAnnotation) resourceAssociationOverrides.next()); |
| } |
| else { |
| removeSpecifiedAssociationOverride_(associationOverride); |
| } |
| } |
| |
| while (resourceAssociationOverrides.hasNext()) { |
| addSpecifiedAssociationOverride(specifiedAssociationOverridesSize(), buildAssociationOverride((AssociationOverrideAnnotation) resourceAssociationOverrides.next())); |
| } |
| } |
| |
| protected JavaAssociationOverride buildAssociationOverride(AssociationOverrideAnnotation associationOverrideResource) { |
| JavaAssociationOverride associationOverride = getJpaFactory().buildJavaAssociationOverride(this, createAssociationOverrideOwner()); |
| associationOverride.initializeFromResource(associationOverrideResource); |
| return associationOverride; |
| } |
| |
| protected void updateVirtualAssociationOverrides(JavaResourcePersistentType resourcePersistentType) { |
| for (Iterator<String> i = allOverridableAssociationNames(); i.hasNext(); ) { |
| String associationName = i.next(); |
| JavaAssociationOverride associationOverride = associationOverrideNamed(associationName); |
| if (associationOverride == null) { |
| associationOverride = buildAssociationOverride(new NullAssociationOverride(resourcePersistentType, associationName)); |
| addVirtualAssociationOverride(associationOverride); |
| } |
| else if (associationOverride.isVirtual()) { |
| associationOverride.update(new NullAssociationOverride(resourcePersistentType, associationName)); |
| } |
| } |
| |
| Collection<String> associationNames = CollectionTools.collection(allOverridableAssociationNames()); |
| |
| //remove any default mappings that are not included in the associationNames collection |
| for (JavaAssociationOverride associationOverride : CollectionTools.iterable(virtualAssociationOverrides())) { |
| if (!associationNames.contains(associationOverride.getName()) |
| || containsSpecifiedAssociationOverride(associationOverride.getName())) { |
| removeVirtualAssociationOverride(associationOverride); |
| } |
| } |
| } |
| |
| protected void updateNamedQueries(JavaResourcePersistentType resourcePersistentType) { |
| ListIterator<JavaNamedQuery> namedQueries = namedQueries(); |
| ListIterator<JavaResourceNode> resourceNamedQueries = resourcePersistentType.annotations(NamedQueryAnnotation.ANNOTATION_NAME, NamedQueriesAnnotation.ANNOTATION_NAME); |
| |
| while (namedQueries.hasNext()) { |
| JavaNamedQuery namedQuery = namedQueries.next(); |
| if (resourceNamedQueries.hasNext()) { |
| namedQuery.update((NamedQueryAnnotation) resourceNamedQueries.next()); |
| } |
| else { |
| removeNamedQuery_(namedQuery); |
| } |
| } |
| |
| while (resourceNamedQueries.hasNext()) { |
| addNamedQuery(namedQueriesSize(), buildNamedQuery((NamedQueryAnnotation) resourceNamedQueries.next())); |
| } |
| } |
| |
| protected void updateNamedNativeQueries(JavaResourcePersistentType resourcePersistentType) { |
| ListIterator<JavaNamedNativeQuery> namedNativeQueries = namedNativeQueries(); |
| ListIterator<JavaResourceNode> resourceNamedNativeQueries = resourcePersistentType.annotations(NamedNativeQueryAnnotation.ANNOTATION_NAME, NamedNativeQueriesAnnotation.ANNOTATION_NAME); |
| |
| while (namedNativeQueries.hasNext()) { |
| JavaNamedNativeQuery namedQuery = namedNativeQueries.next(); |
| if (resourceNamedNativeQueries.hasNext()) { |
| namedQuery.update((NamedNativeQueryAnnotation) resourceNamedNativeQueries.next()); |
| } |
| else { |
| removeNamedNativeQuery_(namedQuery); |
| } |
| } |
| |
| while (resourceNamedNativeQueries.hasNext()) { |
| addNamedNativeQuery(namedNativeQueriesSize(), buildNamedNativeQuery((NamedNativeQueryAnnotation) resourceNamedNativeQueries.next())); |
| } |
| } |
| |
| |
| protected JavaNamedQuery buildNamedQuery(NamedQueryAnnotation namedQueryResource) { |
| JavaNamedQuery namedQuery = getJpaFactory().buildJavaNamedQuery(this); |
| namedQuery.initializeFromResource(namedQueryResource); |
| return namedQuery; |
| } |
| |
| protected JavaNamedNativeQuery buildNamedNativeQuery(NamedNativeQueryAnnotation namedNativeQueryResource) { |
| JavaNamedNativeQuery namedNativeQuery = getJpaFactory().buildJavaNamedNativeQuery(this); |
| namedNativeQuery.initializeFromResource(namedNativeQueryResource); |
| return namedNativeQuery; |
| } |
| |
| protected void updateIdClass(JavaResourcePersistentType resourcePersistentType) { |
| IdClassAnnotation idClass = (IdClassAnnotation) resourcePersistentType.getAnnotation(IdClassAnnotation.ANNOTATION_NAME); |
| if (idClass != null) { |
| setIdClass_(idClass.getValue()); |
| } |
| else { |
| setIdClass_(null); |
| } |
| } |
| |
| protected void updatePersistenceUnitGeneratorsAndQueries() { |
| if (getTableGenerator() != null) { |
| getPersistenceUnit().addGenerator(getTableGenerator()); |
| } |
| |
| if (getSequenceGenerator() != null) { |
| getPersistenceUnit().addGenerator(getSequenceGenerator()); |
| } |
| |
| for (Query query : CollectionTools.iterable(namedQueries())) { |
| getPersistenceUnit().addQuery(query); |
| } |
| |
| for (Query query : CollectionTools.iterable(namedNativeQueries())) { |
| getPersistenceUnit().addQuery(query); |
| } |
| } |
| |
| |
| //******************** Code Completion ************************* |
| |
| @Override |
| public Iterator<String> javaCompletionProposals(int pos, Filter<String> filter, CompilationUnit astRoot) { |
| Iterator<String> result = super.javaCompletionProposals(pos, filter, astRoot); |
| if (result != null) { |
| return result; |
| } |
| result = this.getTable().javaCompletionProposals(pos, filter, astRoot); |
| if (result != null) { |
| return result; |
| } |
| for (JavaSecondaryTable sTable : CollectionTools.iterable(this.secondaryTables())) { |
| result = sTable.javaCompletionProposals(pos, filter, astRoot); |
| if (result != null) { |
| return result; |
| } |
| } |
| for (JavaPrimaryKeyJoinColumn column : CollectionTools.iterable(this.primaryKeyJoinColumns())) { |
| result = column.javaCompletionProposals(pos, filter, astRoot); |
| if (result != null) { |
| return result; |
| } |
| } |
| for (JavaAttributeOverride override : CollectionTools.iterable(this.attributeOverrides())) { |
| result = override.javaCompletionProposals(pos, filter, astRoot); |
| if (result != null) { |
| return result; |
| } |
| } |
| for (JavaAssociationOverride override : CollectionTools.iterable(this.associationOverrides())) { |
| result = override.javaCompletionProposals(pos, filter, astRoot); |
| if (result != null) { |
| return result; |
| } |
| } |
| result = this.getDiscriminatorColumn().javaCompletionProposals(pos, filter, astRoot); |
| if (result != null) { |
| return result; |
| } |
| if (this.getTableGenerator() != null) { |
| result = this.getTableGenerator().javaCompletionProposals(pos, filter, astRoot); |
| if (result != null) { |
| return result; |
| } |
| } |
| if (this.getSequenceGenerator() != null) { |
| result = this.getSequenceGenerator().javaCompletionProposals(pos, filter, astRoot); |
| if (result != null) { |
| return result; |
| } |
| } |
| return null; |
| } |
| |
| |
| //********** Validation ******************************************** |
| |
| @Override |
| public void addToMessages(List<IMessage> messages, CompilationUnit astRoot) { |
| super.addToMessages(messages, astRoot); |
| |
| getTable().addToMessages(messages, astRoot); |
| addIdMessages(messages, astRoot); |
| addGeneratorMessages(messages, astRoot); |
| addQueryMessages(messages, astRoot); |
| |
| for (Iterator<JavaSecondaryTable> stream = this.specifiedSecondaryTables(); stream.hasNext();) { |
| stream.next().addToMessages(messages, astRoot); |
| } |
| |
| for (Iterator<JavaAttributeOverride> stream = this.attributeOverrides(); stream.hasNext();) { |
| stream.next().addToMessages(messages, astRoot); |
| } |
| |
| for (Iterator<JavaAssociationOverride> stream = this.associationOverrides(); stream.hasNext();) { |
| stream.next().addToMessages(messages, astRoot); |
| } |
| |
| } |
| |
| protected void addIdMessages(List<IMessage> messages, CompilationUnit astRoot) { |
| addNoIdMessage(messages, astRoot); |
| } |
| |
| protected void addNoIdMessage(List<IMessage> messages, CompilationUnit astRoot) { |
| if (entityHasNoId()) { |
| messages.add( |
| DefaultJpaValidationMessages.buildMessage( |
| IMessage.HIGH_SEVERITY, |
| JpaValidationMessages.ENTITY_NO_ID, |
| new String[] {this.getName()}, |
| this, this.getValidationTextRange(astRoot)) |
| ); |
| } |
| } |
| |
| private boolean entityHasNoId() { |
| return ! this.entityHasId(); |
| } |
| |
| private boolean entityHasId() { |
| for (Iterator<PersistentAttribute> stream = getPersistentType().allAttributes(); stream.hasNext(); ) { |
| if (stream.next().isIdAttribute()) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| protected void addGeneratorMessages(List<IMessage> messages, CompilationUnit astRoot) { |
| List<Generator> masterList = CollectionTools.list(getPersistenceUnit().allGenerators()); |
| |
| for (Iterator<JavaGenerator> stream = this.generators(); stream.hasNext() ; ) { |
| JavaGenerator current = stream.next(); |
| masterList.remove(current); |
| |
| for (Generator each : masterList) { |
| if (! each.overrides(current) && each.getName() != null && each.getName().equals(current.getName())) { |
| messages.add( |
| DefaultJpaValidationMessages.buildMessage( |
| IMessage.HIGH_SEVERITY, |
| JpaValidationMessages.GENERATOR_DUPLICATE_NAME, |
| new String[] {current.getName()}, |
| current, |
| current.getNameTextRange(astRoot)) |
| ); |
| } |
| } |
| |
| masterList.add(current); |
| } |
| } |
| |
| protected void addQueryMessages(List<IMessage> messages, CompilationUnit astRoot) { |
| List<Query> masterList = CollectionTools.list(getPersistenceUnit().allQueries()); |
| |
| for (Iterator<JavaQuery> stream = this.queries(); stream.hasNext() ; ) { |
| JavaQuery current = stream.next(); |
| masterList.remove(current); |
| |
| for (Query each : masterList) { |
| if (! each.overrides(current) && each.getName() != null && each.getName().equals(current.getName())) { |
| messages.add( |
| DefaultJpaValidationMessages.buildMessage( |
| IMessage.HIGH_SEVERITY, |
| JpaValidationMessages.QUERY_DUPLICATE_NAME, |
| new String[] {current.getName()}, |
| current, |
| current.getNameTextRange(astRoot)) |
| ); |
| } |
| } |
| |
| masterList.add(current); |
| } |
| } |
| |
| class PrimaryKeyJoinColumnOwner implements JavaBaseJoinColumn.Owner |
| { |
| public TextRange getValidationTextRange(CompilationUnit astRoot) { |
| return GenericJavaEntity.this.getValidationTextRange(astRoot); |
| } |
| |
| public TypeMapping getTypeMapping() { |
| return GenericJavaEntity.this; |
| } |
| |
| public org.eclipse.jpt.db.Table getDbTable(String tableName) { |
| return GenericJavaEntity.this.getDbTable(tableName); |
| } |
| |
| public org.eclipse.jpt.db.Table getDbReferencedColumnTable() { |
| Entity parentEntity = GenericJavaEntity.this.getParentEntity(); |
| return (parentEntity == null) ? null : parentEntity.getPrimaryDbTable(); |
| } |
| |
| public int joinColumnsSize() { |
| return GenericJavaEntity.this.primaryKeyJoinColumnsSize(); |
| } |
| |
| public boolean isVirtual(BaseJoinColumn joinColumn) { |
| return GenericJavaEntity.this.defaultPrimaryKeyJoinColumn == joinColumn; |
| } |
| |
| public String getDefaultColumnName() { |
| if (joinColumnsSize() != 1) { |
| return null; |
| } |
| return GenericJavaEntity.this.getParentEntity().getPrimaryKeyColumnName(); |
| } |
| } |
| |
| class AttributeOverrideOwner implements AttributeOverride.Owner { |
| |
| public ColumnMapping getColumnMapping(String attributeName) { |
| if (attributeName == null) { |
| return null; |
| } |
| for (Iterator<PersistentAttribute> stream = getPersistentType().allAttributes(); stream.hasNext();) { |
| PersistentAttribute persAttribute = stream.next(); |
| if (attributeName.equals(persAttribute.getName())) { |
| if (persAttribute.getMapping() instanceof ColumnMapping) { |
| return (ColumnMapping) persAttribute.getMapping(); |
| } |
| } |
| } |
| return null; |
| } |
| |
| public boolean isVirtual(BaseOverride override) { |
| return GenericJavaEntity.this.virtualAttributeOverrides.contains(override); |
| } |
| |
| public BaseOverride setVirtual(boolean virtual, BaseOverride attributeOverride) { |
| return GenericJavaEntity.this.setAttributeOverrideVirtual(virtual, (JavaAttributeOverride) attributeOverride); |
| } |
| |
| public TypeMapping getTypeMapping() { |
| return GenericJavaEntity.this; |
| } |
| |
| public TextRange validationTextRange(CompilationUnit astRoot) { |
| // TODO Auto-generated method stub |
| return null; |
| } |
| } |
| |
| class AssociationOverrideOwner implements AssociationOverride.Owner { |
| |
| public RelationshipMapping getRelationshipMapping(String attributeName) { |
| if (attributeName == null) { |
| return null; |
| } |
| for (Iterator<PersistentAttribute> stream = getPersistentType().allAttributes(); stream.hasNext();) { |
| PersistentAttribute persAttribute = stream.next(); |
| if (attributeName.equals(persAttribute.getName())) { |
| if (persAttribute.getMapping() instanceof RelationshipMapping) { |
| return (RelationshipMapping) persAttribute.getMapping(); |
| } |
| } |
| } |
| return null; |
| } |
| |
| public boolean isVirtual(BaseOverride override) { |
| return GenericJavaEntity.this.virtualAssociationOverrides.contains(override); |
| } |
| |
| public BaseOverride setVirtual(boolean virtual, BaseOverride attributeOverride) { |
| return GenericJavaEntity.this.setAssociationOverrideVirtual(virtual, (JavaAssociationOverride) attributeOverride); |
| } |
| |
| public TypeMapping getTypeMapping() { |
| return GenericJavaEntity.this; |
| } |
| |
| public TextRange validationTextRange(CompilationUnit astRoot) { |
| // TODO Auto-generated method stub |
| return null; |
| } |
| } |
| } |