diff options
Diffstat (limited to 'jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaEntity.java')
| -rw-r--r-- | jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaEntity.java | 1963 |
1 files changed, 0 insertions, 1963 deletions
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaEntity.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaEntity.java deleted file mode 100644 index 9faaa496ef..0000000000 --- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/GenericJavaEntity.java +++ /dev/null @@ -1,1963 +0,0 @@ -/******************************************************************************* - * 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 = getAttributeOverrideNamed(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 = getAssociationOverrideNamed(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 getAttributeOverrideNamed(String name) { - return (JavaAttributeOverride) getOverrideNamed(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 getAssociationOverrideNamed(String name) { - return (JavaAssociationOverride) getOverrideNamed(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 getOverrideNamed(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 getOverrideNamed(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 getPrimaryKeyColumnName(getPersistentType().allAttributes()); - } - - //copied in GenericOrmEntity to avoid an API change for fixing bug 229423 in RC1 - public String getPrimaryKeyColumnName(Iterator<PersistentAttribute> attributes) { - String pkColumnName = null; - for (Iterator<PersistentAttribute> stream = attributes; stream.hasNext();) { - PersistentAttribute attribute = stream.next(); - String name = attribute.getPrimaryKeyColumnName(); - if (name != null) { - //if the attribute is a primary key then we need to check if there is an attribute override - //and use its column name instead (bug 229423) - AttributeOverride attributeOverride = getAttributeOverrideNamed(attribute.getName()); - if (attributeOverride != null) { - name = attributeOverride.getColumn().getName(); - } - } - 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 = getAttributeOverrideNamed(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 = getAssociationOverrideNamed(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; - } - } -} |