jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/EntityMappingsImpl.java

/*******************************************************************************
 * Copyright (c) 2006, 2007 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.orm;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.ListIterator;
import org.eclipse.jpt.core.internal.IMappingKeys;
import org.eclipse.jpt.core.internal.context.base.AccessType;
import org.eclipse.jpt.core.internal.context.base.ISequenceGenerator;
import org.eclipse.jpt.core.internal.context.base.ITableGenerator;
import org.eclipse.jpt.core.internal.context.base.JpaContextNode;
import org.eclipse.jpt.core.internal.resource.orm.Embeddable;
import org.eclipse.jpt.core.internal.resource.orm.Entity;
import org.eclipse.jpt.core.internal.resource.orm.MappedSuperclass;
import org.eclipse.jpt.core.internal.resource.orm.NamedNativeQuery;
import org.eclipse.jpt.core.internal.resource.orm.NamedQuery;
import org.eclipse.jpt.core.internal.resource.orm.OrmFactory;
import org.eclipse.jpt.core.internal.resource.orm.SequenceGenerator;
import org.eclipse.jpt.core.internal.resource.orm.TableGenerator;
import org.eclipse.jpt.core.internal.resource.orm.TypeMapping;
import org.eclipse.jpt.utility.internal.CollectionTools;
import org.eclipse.jpt.utility.internal.iterators.CloneListIterator;


public class EntityMappingsImpl extends JpaContextNode implements EntityMappings
{
	protected org.eclipse.jpt.core.internal.resource.orm.EntityMappings entityMappings;
	
	protected String version;
	
	protected String description;

	protected String package_;

	protected String defaultSchema;

	protected String specifiedSchema;

	protected String defaultCatalog;

	protected String specifiedCatalog;

	protected AccessType defaultAccess;

	protected AccessType specifiedAccess;
		
	protected final PersistenceUnitMetadata persistenceUnitMetadata;

	protected final List<XmlPersistentType> persistentTypes;

	protected final List<XmlSequenceGenerator> sequenceGenerators;
	
	protected final List<XmlTableGenerator> tableGenerators;

	protected final List<XmlNamedQuery> namedQueries;

	protected final List<XmlNamedNativeQuery> namedNativeQueries;


	public EntityMappingsImpl(OrmXml parent) {
		super(parent);
		this.persistenceUnitMetadata = jpaFactory().createPersistenceUnitMetadata(this);
		this.persistentTypes = new ArrayList<XmlPersistentType>();
		this.sequenceGenerators = new ArrayList<XmlSequenceGenerator>();
		this.tableGenerators = new ArrayList<XmlTableGenerator>();
		this.namedQueries = new ArrayList<XmlNamedQuery>();
		this.namedNativeQueries = new ArrayList<XmlNamedNativeQuery>();
	}
	
	@Override
	public EntityMappings entityMappings() {
		return this;
	}
	
	public XmlPersistentType persistentTypeFor(String fullyQualifiedTypeName) {
		for (XmlPersistentType xmlPersistentType : CollectionTools.iterable(xmlPersistentTypes())) {
			if (xmlPersistentType.isFor(fullyQualifiedTypeName)) {
				return xmlPersistentType;
			}
		}
		return null;
	}

	public PersistenceUnitMetadata getPersistenceUnitMetadata() {
		return this.persistenceUnitMetadata;
	}

	public String getPackage() {
		return this.package_;
	}
	
	public void setPackage(String newPackage) {
		String oldPackage = this.package_;
		this.package_ = newPackage;
		this.entityMappings.setPackage(newPackage);
		firePropertyChanged(PACKAGE_PROPERTY, oldPackage, newPackage);
	}

	public String getVersion() {
		return this.version;
	}

	public String getDescription() {
		return this.description;
	}

	public void setDescription(String newDescription) {
		String oldDescription = this.description;
		this.description = newDescription;
		this.entityMappings.setDescription(newDescription);
		firePropertyChanged(DESCRIPTION_PROPERTY, oldDescription, newDescription);
	}

	public String getDefaultSchema() {
		return this.defaultSchema;
	}

	protected void setDefaultSchema(String newDefaultSchema) {
		String oldDefaultSchema = this.defaultSchema;
		this.defaultSchema = newDefaultSchema;
		firePropertyChanged(DEFAULT_SCHEMA_PROPERTY, oldDefaultSchema, newDefaultSchema);
	}

	public String getSpecifiedSchema() {
		return this.specifiedSchema;
	}

	public void setSpecifiedSchema(String newSpecifiedSchema) {
		String oldSpecifiedSchema = this.specifiedSchema;
		this.specifiedSchema = newSpecifiedSchema;
		this.entityMappings.setSchema(newSpecifiedSchema);
		firePropertyChanged(SPECIFIED_SCHEMA_PROPERTY, oldSpecifiedSchema, newSpecifiedSchema);
	}

	public String getSchema() {
		return (this.getSpecifiedSchema() == null) ? this.getDefaultSchema() : this.getSpecifiedSchema();
	}

	public String getDefaultCatalog() {
		return this.defaultCatalog;
	}

	protected void setDefaultCatalog(String newDefaultCatalog) {
		String oldDefaultCatalog = this.defaultCatalog;
		this.defaultCatalog = newDefaultCatalog;
		firePropertyChanged(DEFAULT_CATALOG_PROPERTY, oldDefaultCatalog, newDefaultCatalog);
	}

	public String getSpecifiedCatalog() {
		return this.specifiedCatalog;
	}

	public void setSpecifiedCatalog(String newSpecifiedCatalog) {
		String oldSpecifiedCatalog = this.specifiedCatalog;
		this.specifiedCatalog = newSpecifiedCatalog;
		this.entityMappings.setCatalog(newSpecifiedCatalog);
		firePropertyChanged(SPECIFIED_CATALOG_PROPERTY, oldSpecifiedCatalog, newSpecifiedCatalog);
	}

	public String getCatalog() {
		return (this.getSpecifiedCatalog() == null) ? this.getDefaultCatalog() : this.getSpecifiedCatalog();
	}
	
	public AccessType getAccess() {
		return (this.getSpecifiedAccess() == null) ? this.getDefaultAccess() : this.getSpecifiedAccess();
	}

	public AccessType getDefaultAccess() {
		return this.defaultAccess;
	}

	protected void setDefaultAccess(AccessType newDefaultAccess) {
		AccessType oldDefaultAccess = this.defaultAccess;
		this.defaultAccess = newDefaultAccess;
		firePropertyChanged(DEFAULT_ACCESS_PROPERTY, oldDefaultAccess, newDefaultAccess);
	}

	public AccessType getSpecifiedAccess() {
		return this.specifiedAccess;
	}

	public void setSpecifiedAccess(AccessType newSpecifiedAccess) {
		AccessType oldSpecifiedAccess = this.specifiedAccess;
		this.specifiedAccess = newSpecifiedAccess;
		this.entityMappings.setAccess(AccessType.toXmlResourceModel(newSpecifiedAccess));
		firePropertyChanged(SPECIFIED_ACCESS_PROPERTY, oldSpecifiedAccess, newSpecifiedAccess);
	}

	public ListIterator<XmlPersistentType> xmlPersistentTypes() {
		return new CloneListIterator<XmlPersistentType>(this.persistentTypes);
	}
	
	public int xmlPersistentTypesSize() {
		return this.persistentTypes.size();
	}
	
	public XmlPersistentType addXmlPersistentType(String mappingKey, String className) {
		XmlPersistentType persistentType = jpaFactory().createXmlPersistentType(this, mappingKey);
		int index = insertionIndex(persistentType);
		this.persistentTypes.add(index, persistentType);
		if (className.startsWith(getPackage() + ".")) {
			// adds short name if package name is specified
			className = className.substring(getPackage().length() + 1);
		}
		TypeMapping typeMapping = persistentType.getMapping().addToResourceModel(this.entityMappings);
		typeMapping.setClassName(className);
		fireItemAdded(PERSISTENT_TYPES_LIST, index, persistentType);
		return persistentType;
	}
	
	protected void addXmlPersistentType(XmlPersistentType xmlPersistentType) { 
		addItemToList(xmlPersistentType, this.persistentTypes, PERSISTENT_TYPES_LIST);
	}

	protected int insertionIndex(XmlPersistentType persistentType) {
		return CollectionTools.insertionIndexOf(this.persistentTypes, persistentType, buildMappingComparator());
	}

	private Comparator<XmlPersistentType> buildMappingComparator() {
		return new Comparator<XmlPersistentType>() {
			public int compare(XmlPersistentType o1, XmlPersistentType o2) {
				int o1Sequence = o1.getMapping().xmlSequence();
				int o2Sequence = o2.getMapping().xmlSequence();
				if (o1Sequence < o2Sequence) {
					return -1;
				}
				if (o1Sequence == o2Sequence) {
					return 0;
				}
				return 1;
			}
		};
	}

	public void removeXmlPersistentType(int index) {
		XmlPersistentType xmlPersistentType = this.persistentTypes.get(index);		
		this.persistentTypes.remove(index);
		xmlPersistentType.getMapping().removeFromResourceModel(this.entityMappings);
		fireItemRemoved(PERSISTENT_TYPES_LIST, index, xmlPersistentType);		
	}
	
	public void removeXmlPersistentType(XmlPersistentType xmlPersistentType) {
		removeXmlPersistentType(this.persistentTypes.indexOf(xmlPersistentType));	
	}
	
	protected void removeXmlPersistentType_(XmlPersistentType xmlPersistentType) {
		removeItemFromList(xmlPersistentType, this.persistentTypes, PERSISTENT_TYPES_LIST);
	}

	public void changeMapping(XmlPersistentType xmlPersistentType, XmlTypeMapping<? extends TypeMapping> oldMapping, XmlTypeMapping<? extends TypeMapping> newMapping) {
		int sourceIndex = this.persistentTypes.indexOf(xmlPersistentType);
		this.persistentTypes.remove(sourceIndex);
		oldMapping.removeFromResourceModel(this.entityMappings);
		int targetIndex = insertionIndex(xmlPersistentType);
		this.persistentTypes.add(targetIndex, xmlPersistentType);
		newMapping.addToResourceModel(this.entityMappings);
		newMapping.initializeFrom(oldMapping);
		//TODO are the source and target correct in this case, or is target off by one???
		fireItemMoved(PERSISTENT_TYPES_LIST, targetIndex, sourceIndex);
	}


	@SuppressWarnings("unchecked")
	public ListIterator<XmlSequenceGenerator> sequenceGenerators() {
		return new CloneListIterator<XmlSequenceGenerator>(this.sequenceGenerators);
	}

	public int sequenceGeneratorsSize() {
		return this.sequenceGenerators.size();
	}
	
	public ISequenceGenerator addSequenceGenerator(int index) {
		XmlSequenceGenerator xmlSequenceGenerator = new XmlSequenceGenerator(this);
		this.sequenceGenerators.add(index, xmlSequenceGenerator);
		SequenceGenerator sequenceGenerator = OrmFactory.eINSTANCE.createSequenceGeneratorImpl();
		xmlSequenceGenerator.initialize(sequenceGenerator);
		this.entityMappings.getSequenceGenerators().add(index, sequenceGenerator);
		fireItemAdded(SEQUENCE_GENERATORS_LIST, index, xmlSequenceGenerator);
		return xmlSequenceGenerator;
	}

	protected void addSequenceGenerator(int index, XmlSequenceGenerator sequenceGenerator) {
		addItemToList(index, sequenceGenerator, this.sequenceGenerators, EntityMappings.SEQUENCE_GENERATORS_LIST);
	}

	public void removeSequenceGenerator(int index) {
		XmlSequenceGenerator removedSequenceGenerator = this.sequenceGenerators.remove(index);
		fireItemRemoved(SEQUENCE_GENERATORS_LIST, index, removedSequenceGenerator);
		this.entityMappings.getSequenceGenerators().remove(index);
	}
	
	protected void removeSequenceGenerator(XmlSequenceGenerator sequenceGenerator) {
		removeItemFromList(sequenceGenerator, this.sequenceGenerators, EntityMappings.SEQUENCE_GENERATORS_LIST);
	}

	public void moveSequenceGenerator(int targetIndex, int sourceIndex) {
		CollectionTools.move(this.sequenceGenerators, targetIndex, sourceIndex);
		this.entityMappings.getSequenceGenerators().move(targetIndex, sourceIndex);
		fireItemMoved(EntityMappings.SEQUENCE_GENERATORS_LIST, targetIndex, sourceIndex);	
	}

	
	@SuppressWarnings("unchecked")
	public ListIterator<XmlTableGenerator> tableGenerators() {
		return new CloneListIterator<XmlTableGenerator>(this.tableGenerators);
	}

	public int tableGeneratorsSize() {
		return this.tableGenerators.size();
	}
	
	public ITableGenerator addTableGenerator(int index) {
		XmlTableGenerator xmlTableGenerator = new XmlTableGenerator(this);
		this.tableGenerators.add(index, xmlTableGenerator);
		TableGenerator tableGenerator = OrmFactory.eINSTANCE.createTableGeneratorImpl();
		xmlTableGenerator.initialize(tableGenerator);
		this.entityMappings.getTableGenerators().add(index, tableGenerator);
		fireItemAdded(TABLE_GENERATORS_LIST, index, xmlTableGenerator);
		return xmlTableGenerator;
	}
	
	protected void addTableGenerator(int index, XmlTableGenerator tableGenerator) {
		addItemToList(index, tableGenerator, this.tableGenerators, EntityMappings.TABLE_GENERATORS_LIST);
	}

	public void removeTableGenerator(int index) {
		XmlTableGenerator removedTableGenerator = this.tableGenerators.remove(index);
		this.entityMappings.getTableGenerators().remove(index);
		fireItemRemoved(TABLE_GENERATORS_LIST, index, removedTableGenerator);
	}
	
	protected void removeTableGenerator(XmlTableGenerator tableGenerator) {
		removeItemFromList(tableGenerator, this.tableGenerators, EntityMappings.TABLE_GENERATORS_LIST);
	}

	public void moveTableGenerator(int targetIndex, int sourceIndex) {
		CollectionTools.move(this.tableGenerators, targetIndex, sourceIndex);
		this.entityMappings.getTableGenerators().move(targetIndex, sourceIndex);
		fireItemMoved(EntityMappings.TABLE_GENERATORS_LIST, targetIndex, sourceIndex);	
	}

	public ListIterator<XmlNamedQuery> namedQueries() {
		return new CloneListIterator<XmlNamedQuery>(this.namedQueries);
	}
	
	public int namedQueriesSize() {
		return this.namedQueries.size();
	}
	
	public XmlNamedQuery addNamedQuery(int index) {
		XmlNamedQuery namedQuery = new XmlNamedQuery(this);
		this.namedQueries.add(index, namedQuery);
		this.entityMappings.getNamedQueries().add(index, OrmFactory.eINSTANCE.createNamedQuery());
		this.fireItemAdded(EntityMappings.NAMED_QUERIES_LIST, index, namedQuery);
		return namedQuery;
	}
	
	protected void addNamedQuery(int index, XmlNamedQuery namedQuery) {
		addItemToList(index, namedQuery, this.namedQueries, EntityMappings.NAMED_QUERIES_LIST);
	}
	
	public void removeNamedQuery(int index) {
		XmlNamedQuery namedQuery = this.namedQueries.remove(index);
		this.entityMappings.getNamedQueries().remove(index);
		fireItemRemoved(EntityMappings.NAMED_QUERIES_LIST, index, namedQuery);
	}

	protected void removeNamedQuery(XmlNamedQuery namedQuery) {
		removeItemFromList(namedQuery, this.namedQueries, EntityMappings.NAMED_QUERIES_LIST);
	}
	
	public void moveNamedQuery(int targetIndex, int sourceIndex) {
		this.entityMappings.getNamedQueries().move(targetIndex, sourceIndex);
		moveItemInList(targetIndex, sourceIndex, this.namedQueries, EntityMappings.NAMED_QUERIES_LIST);		
	}
	
	public ListIterator<XmlNamedNativeQuery> namedNativeQueries() {
		return new CloneListIterator<XmlNamedNativeQuery>(this.namedNativeQueries);
	}
	
	public int namedNativeQueriesSize() {
		return this.namedNativeQueries.size();
	}
	
	public XmlNamedNativeQuery addNamedNativeQuery(int index) {
		XmlNamedNativeQuery namedNativeQuery = new XmlNamedNativeQuery(this);
		this.namedNativeQueries.add(index, namedNativeQuery);
		this.entityMappings.getNamedNativeQueries().add(index, OrmFactory.eINSTANCE.createNamedNativeQuery());
		this.fireItemAdded(EntityMappings.NAMED_QUERIES_LIST, index, namedNativeQuery);
		return namedNativeQuery;
	}
	
	protected void addNamedNativeQuery(int index, XmlNamedNativeQuery namedNativeQuery) {
		addItemToList(index, namedNativeQuery, this.namedNativeQueries, EntityMappings.NAMED_NATIVE_QUERIES_LIST);
	}
	
	public void removeNamedNativeQuery(int index) {
		XmlNamedNativeQuery namedNativeQuery = this.namedNativeQueries.remove(index);
		this.entityMappings.getNamedNativeQueries().remove(index);
		fireItemRemoved(EntityMappings.NAMED_QUERIES_LIST, index, namedNativeQuery);
	}

	protected void removeNamedNativeQuery(XmlNamedNativeQuery namedNativeQuery) {
		removeItemFromList(namedNativeQuery, this.namedNativeQueries, EntityMappings.NAMED_NATIVE_QUERIES_LIST);
	}
	
	public void moveNamedNativeQuery(int targetIndex, int sourceIndex) {
		this.entityMappings.getNamedNativeQueries().move(targetIndex, sourceIndex);
		moveItemInList(targetIndex, sourceIndex, this.namedNativeQueries, EntityMappings.NAMED_NATIVE_QUERIES_LIST);		
	}

	//TODO what about qualified name?  package + class
	//this needs to be handled both for className and persistentType.getName().
	//moving on for now since I am just trying to get the ui compiled!  just a warning that this isn't good api
	public boolean containsPersistentType(String className) {
		for (XmlPersistentType persistentType : CollectionTools.iterable(xmlPersistentTypes())) {
			if (persistentType.getName().equals(className)) {
				return true;
			}
		}
		return false;
	}

//	/* @see IJpaContentNode#getId() */
//	public Object getId() {
//		return IXmlContentNodes.ENTITY_MAPPINGS_ID;
//	}
//
//	public IJpaContentNode getContentNode(int offset) {
//		for (Iterator i = getTypeMappings().iterator(); i.hasNext();) {
//			XmlTypeMapping mapping = (XmlTypeMapping) i.next();
//			if (mapping.getNode().contains(offset)) {
//				return mapping.getContentNode(offset);
//			}
//		}
//		return this;
//	}
//
//	public void javaElementChanged(ElementChangedEvent event) {
//	}

	public PersistenceUnitDefaults persistenceUnitDefaults() {
		return getPersistenceUnitMetadata().getPersistenceUnitDefaults();
	}
	
	public void initialize(org.eclipse.jpt.core.internal.resource.orm.EntityMappings entityMappings) {
		this.entityMappings = entityMappings;
		this.version = entityMappings.getVersion();
		this.description = entityMappings.getDescription();
		this.package_ = entityMappings.getPackage();
		this.specifiedSchema = entityMappings.getSchema();
		this.specifiedCatalog = entityMappings.getCatalog();
		this.specifiedAccess = this.specifiedAccess(entityMappings);
		this.persistenceUnitMetadata.initialize(entityMappings);
		this.defaultAccess = persistenceUnit().getDefaultAccess();
		this.defaultCatalog = persistenceUnit().getDefaultCatalog();
		this.defaultSchema = persistenceUnit().getDefaultSchema();
		this.initializePersistentTypes(entityMappings);
		this.initializeTableGenerators(entityMappings);
		this.initializeSequenceGenerators(entityMappings);
		this.initializeNamedQueries(entityMappings);
		this.initializeNamedNativeQueries(entityMappings);
	}
	
	protected void initializePersistentTypes(org.eclipse.jpt.core.internal.resource.orm.EntityMappings entityMappings) {
		this.initializeMappedSuperclasses(entityMappings);
		this.initializeEntities(entityMappings);
		this.initializeEmbeddables(entityMappings);
	}
	
	protected void initializeMappedSuperclasses(org.eclipse.jpt.core.internal.resource.orm.EntityMappings entityMappings) {
		for (MappedSuperclass mappedSuperclass : entityMappings.getMappedSuperclasses()) {
			XmlPersistentType xmlPersistentType = jpaFactory().createXmlPersistentType(this, IMappingKeys.MAPPED_SUPERCLASS_TYPE_MAPPING_KEY);
			xmlPersistentType.initialize(mappedSuperclass);
			this.persistentTypes.add(xmlPersistentType);
		}	
	}
	
	protected void initializeEntities(org.eclipse.jpt.core.internal.resource.orm.EntityMappings entityMappings) {
		for (Entity entity : entityMappings.getEntities()) {
			XmlPersistentType xmlPersistentType = jpaFactory().createXmlPersistentType(this, IMappingKeys.ENTITY_TYPE_MAPPING_KEY);
			xmlPersistentType.initialize(entity);
			this.persistentTypes.add(xmlPersistentType);
		}				
	}
	
	protected void initializeEmbeddables(org.eclipse.jpt.core.internal.resource.orm.EntityMappings entityMappings) {
		for (Embeddable embeddable : entityMappings.getEmbeddables()) {
			XmlPersistentType xmlPersistentType = jpaFactory().createXmlPersistentType(this, IMappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY);
			xmlPersistentType.initialize(embeddable);
			this.persistentTypes.add(xmlPersistentType);
		}
	}
	
	protected void initializeTableGenerators(org.eclipse.jpt.core.internal.resource.orm.EntityMappings entityMappings) {
		for (TableGenerator tableGenerator : entityMappings.getTableGenerators()) {
			XmlTableGenerator xmlTableGenerator = new XmlTableGenerator(this);
			xmlTableGenerator.initialize(tableGenerator);
			this.tableGenerators.add(xmlTableGenerator);
		}
	}
	
	protected void initializeSequenceGenerators(org.eclipse.jpt.core.internal.resource.orm.EntityMappings entityMappings) {
		for (SequenceGenerator sequenceGenerator : entityMappings.getSequenceGenerators()) {
			XmlSequenceGenerator xmlSequenceGenerator = new XmlSequenceGenerator(this);
			xmlSequenceGenerator.initialize(sequenceGenerator);
			this.sequenceGenerators.add(xmlSequenceGenerator);
		}
	}
	
	protected void initializeNamedQueries(org.eclipse.jpt.core.internal.resource.orm.EntityMappings entityMappings) {
		for (NamedQuery namedQuery : entityMappings.getNamedQueries()) {
			this.namedQueries.add(createNamedQuery(namedQuery));
		}
	}
	
	protected void initializeNamedNativeQueries(org.eclipse.jpt.core.internal.resource.orm.EntityMappings entityMappings) {
		for (NamedNativeQuery namedNativeQuery : entityMappings.getNamedNativeQueries()) {
			this.namedNativeQueries.add(createNamedNativeQuery(namedNativeQuery));
		}
	}

	public void update(org.eclipse.jpt.core.internal.resource.orm.EntityMappings entityMappings) {
		this.entityMappings = entityMappings;
		this.setDescription(entityMappings.getDescription());
		this.setPackage(entityMappings.getPackage());
		this.setSpecifiedSchema(entityMappings.getSchema());
		this.setSpecifiedCatalog(entityMappings.getCatalog());
		this.setSpecifiedAccess(this.specifiedAccess(entityMappings));
		this.persistenceUnitMetadata.update(entityMappings);
		this.setDefaultAccess(persistenceUnit().getDefaultAccess());
		this.setDefaultCatalog(persistenceUnit().getDefaultCatalog());
		this.setDefaultSchema(persistenceUnit().getDefaultSchema());
		this.updatePersistentTypes(entityMappings);
		this.updateTableGenerators(entityMappings);
		this.updateSequenceGenerators(entityMappings);
		this.updateNamedQueries(entityMappings);
		this.updateNamedNativeQueries(entityMappings);
	}
	
	protected AccessType specifiedAccess(org.eclipse.jpt.core.internal.resource.orm.EntityMappings entityMappings) {
		return AccessType.fromXmlResourceModel(entityMappings.getAccess());
	}
	
	protected void updatePersistentTypes(org.eclipse.jpt.core.internal.resource.orm.EntityMappings entityMappings) {
		ListIterator<XmlPersistentType> xmlPersistentTypes = this.xmlPersistentTypes();
		this.updateMappedSuperclasses(entityMappings, xmlPersistentTypes);
		this.updateEntities(entityMappings, xmlPersistentTypes);
		this.updateEmbeddables(entityMappings, xmlPersistentTypes);
		
		while (xmlPersistentTypes.hasNext()) {
			this.removeXmlPersistentType(xmlPersistentTypes.next());
		}		
	}
	
	protected void updateMappedSuperclasses(org.eclipse.jpt.core.internal.resource.orm.EntityMappings entityMappings, ListIterator<XmlPersistentType> xmlPersistentTypes) {
		for (MappedSuperclass mappedSuperclass : entityMappings.getMappedSuperclasses()) {
			if (xmlPersistentTypes.hasNext()) {
				xmlPersistentTypes.next().update(mappedSuperclass);
			}
			else {
				XmlPersistentType xmlPersistentType = jpaFactory().createXmlPersistentType(this, IMappingKeys.MAPPED_SUPERCLASS_TYPE_MAPPING_KEY);
				xmlPersistentType.initialize(mappedSuperclass);
				addXmlPersistentType(xmlPersistentType);
			}
		}
	}
	
	protected void updateEntities(org.eclipse.jpt.core.internal.resource.orm.EntityMappings entityMappings, ListIterator<XmlPersistentType> xmlPersistentTypes) {
		for (Entity entity : entityMappings.getEntities()) {
			if (xmlPersistentTypes.hasNext()) {
				xmlPersistentTypes.next().update(entity);
			}
			else {
				XmlPersistentType xmlPersistentType = jpaFactory().createXmlPersistentType(this, IMappingKeys.ENTITY_TYPE_MAPPING_KEY);
				xmlPersistentType.initialize(entity);
				addXmlPersistentType(xmlPersistentType);
			}
		}
	}
	
	protected void updateEmbeddables(org.eclipse.jpt.core.internal.resource.orm.EntityMappings entityMappings, ListIterator<XmlPersistentType> xmlPersistentTypes) {
		for (Embeddable embeddable : entityMappings.getEmbeddables()) {
			if (xmlPersistentTypes.hasNext()) {
				xmlPersistentTypes.next().update(embeddable);
			}
			else {
				XmlPersistentType xmlPersistentType = jpaFactory().createXmlPersistentType(this, IMappingKeys.EMBEDDABLE_TYPE_MAPPING_KEY);
				xmlPersistentType.initialize(embeddable);
				addXmlPersistentType(xmlPersistentType);
			}
		}
	}
	
	protected void updateTableGenerators(org.eclipse.jpt.core.internal.resource.orm.EntityMappings entityMappings) {
		ListIterator<XmlTableGenerator> tableGenerators = tableGenerators();
		ListIterator<TableGenerator> resourceTableGenerators = entityMappings.getTableGenerators().listIterator();
		while (tableGenerators.hasNext()) {
			XmlTableGenerator tableGenerator = tableGenerators.next();
			if (resourceTableGenerators.hasNext()) {
				tableGenerator.update(resourceTableGenerators.next());
			}
			else {
				removeTableGenerator(tableGenerator);
			}
		}
		
		while (resourceTableGenerators.hasNext()) {
			addTableGenerator(tableGeneratorsSize(), createTableGenerator(resourceTableGenerators.next()));
		}
	}

	protected XmlTableGenerator createTableGenerator(TableGenerator tableGeneratorResource) {
		XmlTableGenerator tableGenerator = new XmlTableGenerator(this);
		tableGenerator.initialize(tableGeneratorResource);
		return tableGenerator;
	}

	protected void updateSequenceGenerators(org.eclipse.jpt.core.internal.resource.orm.EntityMappings entityMappings) {
		ListIterator<XmlSequenceGenerator> sequenceGenerators = sequenceGenerators();
		ListIterator<SequenceGenerator> resourceSequenceGenerators = entityMappings.getSequenceGenerators().listIterator();
		while (sequenceGenerators.hasNext()) {
			XmlSequenceGenerator sequenceGenerator = sequenceGenerators.next();
			if (resourceSequenceGenerators.hasNext()) {
				sequenceGenerator.update(resourceSequenceGenerators.next());
			}
			else {
				removeSequenceGenerator(sequenceGenerator);
			}
		}
		
		while (resourceSequenceGenerators.hasNext()) {
			addSequenceGenerator(sequenceGeneratorsSize(), createSequenceGenerator(resourceSequenceGenerators.next()));
		}
	}

	protected XmlSequenceGenerator createSequenceGenerator(SequenceGenerator sequenceGeneratorResource) {
		XmlSequenceGenerator sequenceGenerator = new XmlSequenceGenerator(this);
		sequenceGenerator.initialize(sequenceGeneratorResource);
		return sequenceGenerator;
	}
	
	protected void updateNamedQueries(org.eclipse.jpt.core.internal.resource.orm.EntityMappings entityMappings) {
		ListIterator<XmlNamedQuery> namedQueries = namedQueries();
		ListIterator<NamedQuery> resourceNamedQueries = entityMappings.getNamedQueries().listIterator();
		
		while (namedQueries.hasNext()) {
			XmlNamedQuery namedQuery = namedQueries.next();
			if (resourceNamedQueries.hasNext()) {
				namedQuery.update(resourceNamedQueries.next());
			}
			else {
				removeNamedQuery(namedQuery);
			}
		}
		
		while (resourceNamedQueries.hasNext()) {
			addNamedQuery(namedQueriesSize(), createNamedQuery(resourceNamedQueries.next()));
		}
	}

	protected XmlNamedQuery createNamedQuery(NamedQuery namedQuery) {
		XmlNamedQuery xmlNamedQuery = new XmlNamedQuery(this);
		xmlNamedQuery.initialize(namedQuery);
		return xmlNamedQuery;
	}

	protected void updateNamedNativeQueries(org.eclipse.jpt.core.internal.resource.orm.EntityMappings entityMappings) {
		ListIterator<XmlNamedNativeQuery> namedNativeQueries = namedNativeQueries();
		ListIterator<NamedNativeQuery> resourceNamedNativeQueries = entityMappings.getNamedNativeQueries().listIterator();
		
		while (namedNativeQueries.hasNext()) {
			XmlNamedNativeQuery namedQuery = namedNativeQueries.next();
			if (resourceNamedNativeQueries.hasNext()) {
				namedQuery.update(resourceNamedNativeQueries.next());
			}
			else {
				removeNamedNativeQuery(namedQuery);
			}
		}
		
		while (resourceNamedNativeQueries.hasNext()) {
			addNamedNativeQuery(namedQueriesSize(), createNamedNativeQuery(resourceNamedNativeQueries.next()));
		}
	}

	protected XmlNamedNativeQuery createNamedNativeQuery(NamedNativeQuery namedQuery) {
		XmlNamedNativeQuery xmlNamedNativeQuery = new XmlNamedNativeQuery(this);
		xmlNamedNativeQuery.initialize(namedQuery);
		return xmlNamedNativeQuery;
	}


}