diff options
author | pfullbright | 2009-08-04 15:05:13 +0000 |
---|---|---|
committer | pfullbright | 2009-08-04 15:05:13 +0000 |
commit | 8f1f9c356e97be6e734b2fa12e6eb59994e91db9 (patch) | |
tree | a4f548dfb25a7caef3b04065b6c033105de01200 /jpa/plugins/org.eclipse.jpt.core/src/org | |
parent | ef7b5de41b75261ab5ee01711118316956c99a1b (diff) | |
download | webtools.dali-8f1f9c356e97be6e734b2fa12e6eb59994e91db9.tar.gz webtools.dali-8f1f9c356e97be6e734b2fa12e6eb59994e91db9.tar.xz webtools.dali-8f1f9c356e97be6e734b2fa12e6eb59994e91db9.zip |
model framework changes necessary to support derived id's
Diffstat (limited to 'jpa/plugins/org.eclipse.jpt.core/src/org')
40 files changed, 1177 insertions, 1037 deletions
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/JpaPlatform.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/JpaPlatform.java index 0f7a526c8b..2ca5005967 100644 --- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/JpaPlatform.java +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/JpaPlatform.java @@ -11,19 +11,12 @@ package org.eclipse.jpt.core; import org.eclipse.core.resources.IFile; import org.eclipse.core.runtime.content.IContentType; -import org.eclipse.jpt.core.context.MappingFile; -import org.eclipse.jpt.core.context.java.JavaAttributeMapping; +import org.eclipse.jpt.core.context.MappingFileDefinition; +import org.eclipse.jpt.core.context.java.JavaAttributeMappingProvider; +import org.eclipse.jpt.core.context.java.NullDefaultJavaAttributeMappingProvider; import org.eclipse.jpt.core.context.java.JavaPersistentAttribute; import org.eclipse.jpt.core.context.java.JavaPersistentType; import org.eclipse.jpt.core.context.java.JavaTypeMapping; -import org.eclipse.jpt.core.context.orm.OrmAttributeMapping; -import org.eclipse.jpt.core.context.orm.OrmPersistentAttribute; -import org.eclipse.jpt.core.context.orm.OrmPersistentType; -import org.eclipse.jpt.core.context.orm.OrmTypeMapping; -import org.eclipse.jpt.core.context.persistence.MappingFileRef; -import org.eclipse.jpt.core.resource.orm.XmlAttributeMapping; -import org.eclipse.jpt.core.resource.orm.XmlTypeMapping; -import org.eclipse.jpt.core.resource.xml.JpaXmlResource; import org.eclipse.jpt.core.utility.jdt.AnnotationEditFormatter; import org.eclipse.jpt.db.ConnectionProfileFactory; import org.eclipse.jpt.db.DatabaseFinder; @@ -89,8 +82,8 @@ public interface JpaPlatform AnnotationEditFormatter getAnnotationEditFormatter(); - // ********** Java type mappings ********** - + // ********** Java type/attribute mappings ********** + /** * Build a Java type mapping for the specified key and persistent type. * Use identity when comparing keys; so clients must use the same key @@ -99,7 +92,7 @@ public interface JpaPlatform * platform. */ JavaTypeMapping buildJavaTypeMappingFromMappingKey(String key, JavaPersistentType type); - + /** * Build a Java type mapping for the specified annotation and persistent * type. Use identity when comparing annotation names; so clients must @@ -108,77 +101,50 @@ public interface JpaPlatform * supported by the platform. */ JavaTypeMapping buildJavaTypeMappingFromAnnotation(String annotationName, JavaPersistentType type); - - - // ********** Java attribute mappings ********** - - /** - * Build a Java attribute mapping for the specified key and persistent attribute. - * Use identity when comparing keys; so clients must use the same key - * constants as the providers. - * Throw an IllegalArgumentException if the key is not supported by the - * platform. - */ - JavaAttributeMapping buildJavaAttributeMappingFromMappingKey(String key, JavaPersistentAttribute attribute); - - /** - * Build a Java attribute mapping for the specified annotation and persistent - * attribute. Use identity when comparing annotation names; so clients must - * use the same name constants as the providers. - * Throw an IllegalArgumentException if the mapping annotation is not - * supported by the platform. - */ - JavaAttributeMapping buildJavaAttributeMappingFromAnnotation(String annotationName, JavaPersistentAttribute attribute); - - /** - * Build a default Java attribute mapping for the specified persistent attribute. - */ - JavaAttributeMapping buildDefaultJavaAttributeMapping(JavaPersistentAttribute attribute); - + /** - * Return the Java attribute mapping key for the default mapping for the - * specified attribute. - * @see org.eclipse.jpt.core.context.java.DefaultJavaAttributeMappingProvider#defaultApplies(JavaPersistentAttribute) + * Return a {@link JavaAttributeMappingProvider} that describes the interpretation of the attribute + * as it exists, ignoring all annotations. + * This may not be null (@see {@link NullDefaultJavaAttributeMappingProvider},) else + * an {@link IllegalStateException} is thrown. + * + * @param attribute The persistent attribute to analyze + * @return The mapping provider describing the unannotated state of the attribute */ - String getDefaultJavaAttributeMappingKey(JavaPersistentAttribute attribute); - - - // ********** Mapping File ********** - - MappingFile buildMappingFile(MappingFileRef parent, JpaXmlResource resource); - - - // ********** ORM type mappings ********** - - XmlTypeMapping buildOrmResourceTypeMapping(String key, IContentType contentType); - + JavaAttributeMappingProvider getDefaultJavaAttributeMappingProvider(JavaPersistentAttribute attribute); + /** - * Build an ORM type mapping for the specified mapping key and persistent type. - * Use identity when comparing keys; so clients must use the same key - * constants as the providers. + * Return a {@link JavaAttributeMappingProvider} that describes the interpretation of the attribute + * as it exists, complete with annotations. It is assumed that the attribute's default mapping + * has already been determined. + * This may be null. + * + * @param attribute The persistent attribute to analyze + * @return The mapping provider describing the annotated state of the attribute */ - OrmTypeMapping buildOrmTypeMappingFromMappingKey(OrmPersistentType type, XmlTypeMapping resourceMapping); - - - // ********** ORM attribute mappings ********** - - XmlAttributeMapping buildOrmResourceAttributeMapping(String key, IContentType contentType); - + JavaAttributeMappingProvider getSpecifiedJavaAttributeMappingProvider(JavaPersistentAttribute attribute); + /** - * Build an ORM attribute mapping for the specified key and persistent attribute. - * Use identity when comparing keys; so clients must use the same key - * constants as the providers. + * Return a {@link JavaAttributeMappingProvider} for the given mapping key. + * Throw an {@link IllegalArgumentException} if the key is not supported by the platform. */ - OrmAttributeMapping buildOrmAttributeMappingFromMappingKey(OrmPersistentAttribute parent, XmlAttributeMapping resourceMapping); - + JavaAttributeMappingProvider getSpecifiedJavaAttributeMappingProvider(String mappingKey); + + + // ********** Mapping Files ********** + /** - * Build a virtual resource attribute mapping to be used when the mapping is not specified in the orm.xml - * file. There is no XmlAttributeMapping in this case, so we build one that delegates to the - * JavaAttributeMapping as necessary + * Return a {@link MappingFileDefinition} to describe the context model for a file of the given + * content type. + * Thrown an {@link IllegalArgumentException} if the content type is not supported by the platform. + * + * @param contentType The content type of a potential mapping file + * @return The mapping file definition that can be used to describe the context model of such + * a file */ - XmlAttributeMapping buildVirtualOrmResourceMappingFromMappingKey(String key, OrmTypeMapping ormTypeMapping, JavaAttributeMapping javaAttributeMapping); - - + MappingFileDefinition getMappingFileDefinition(IContentType contentType); + + // ********** database ********** /** diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/JpaPlatformProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/JpaPlatformProvider.java index 63944f68dd..7e779dcff7 100644 --- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/JpaPlatformProvider.java +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/JpaPlatformProvider.java @@ -10,12 +10,9 @@ package org.eclipse.jpt.core; import java.util.ListIterator; -import org.eclipse.jpt.core.context.MappingFileProvider; -import org.eclipse.jpt.core.context.java.DefaultJavaAttributeMappingProvider; +import org.eclipse.jpt.core.context.MappingFileDefinition; import org.eclipse.jpt.core.context.java.JavaAttributeMappingProvider; import org.eclipse.jpt.core.context.java.JavaTypeMappingProvider; -import org.eclipse.jpt.core.context.orm.OrmAttributeMappingProvider; -import org.eclipse.jpt.core.context.orm.OrmTypeMappingProvider; /** * This interface is to be implemented by a JPA vendor to provide extensions to @@ -44,33 +41,22 @@ public interface JpaPlatformProvider ListIterator<JpaResourceModelProvider> resourceModelProviders(); /** - * Return the java type mapping providers that apply to this platform. - */ - ListIterator<JavaTypeMappingProvider> javaTypeMappingProviders(); - - /** - * Return the java attribute mapping providers that apply to this platform. - */ - ListIterator<JavaAttributeMappingProvider> javaAttributeMappingProviders(); - - /** - * Return the mapping file providers that apply to this platform. + * Return the mapping file definitions supported by this platform. */ - ListIterator<MappingFileProvider> mappingFileProviders(); + ListIterator<MappingFileDefinition> mappingFileDefinitions(); /** - * Return the default java attribute mapping providers that apply to this platform. + * Return the java type mapping providers that apply to this platform. */ - ListIterator<DefaultJavaAttributeMappingProvider> defaultJavaAttributeMappingProviders(); - + ListIterator<JavaTypeMappingProvider> javaTypeMappingProviders(); + /** - * Return the orm type mapping providers that apply to this platform. + * Return the mapping providers to use for default java attribute mappings for this platform. */ - ListIterator<OrmTypeMappingProvider> ormTypeMappingProviders(); + ListIterator<JavaAttributeMappingProvider> defaultJavaAttributeMappingProviders(); /** - * Return the orm attribute mapping providers that apply to this platform. + * Return the mapping providers to use for specified java attribute mappings for this platform. */ - ListIterator<OrmAttributeMappingProvider> ormAttributeMappingProviders(); - + ListIterator<JavaAttributeMappingProvider> specifiedJavaAttributeMappingProviders(); } diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/MappingFileProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/MappingFileDefinition.java index 1528ec9aaa..266bffad5e 100644 --- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/MappingFileProvider.java +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/MappingFileDefinition.java @@ -11,6 +11,9 @@ package org.eclipse.jpt.core.context; import org.eclipse.core.runtime.content.IContentType; import org.eclipse.jpt.core.JpaFactory; +import org.eclipse.jpt.core.context.orm.OrmAttributeMappingProvider; +import org.eclipse.jpt.core.context.orm.NullOrmAttributeMappingProvider; +import org.eclipse.jpt.core.context.orm.OrmTypeMappingProvider; import org.eclipse.jpt.core.context.persistence.MappingFileRef; import org.eclipse.jpt.core.resource.xml.JpaXmlResource; @@ -21,8 +24,8 @@ import org.eclipse.jpt.core.resource.xml.JpaXmlResource; * pioneering adopters on the understanding that any code that uses this API * will almost certainly be broken (repeatedly) as the API evolves. */ -public interface MappingFileProvider { - +public interface MappingFileDefinition +{ /** * Return the associated mapping file content type. */ @@ -32,5 +35,26 @@ public interface MappingFileProvider { * Build a mapping with the specified parent and resource. */ MappingFile buildMappingFile(MappingFileRef parent, JpaXmlResource resource, JpaFactory factory); - + + + // ********** ORM type/attribute mappings ********** + + /** + * Return an {@link OrmTypeMappingProvider} for the given type mapping key. + * Throws an {@link IllegalArgumentException} if the mapping key is not supported. + * + * @param mappingKey The type mapping key + * @return The mapping provider for the given mapping key + */ + OrmTypeMappingProvider getOrmTypeMappingProvider(String mappingKey); + + /** + * Return an {@link OrmAttributeMappingProvider} for the given attribute mapping key. + * This must not return null. (@see {@link NullOrmAttributeMappingProvider}) + * Throws an {@link IllegalArgumentException} if the mapping key is not supported. + * + * @param mappingKey The attribute mapping key + * @return The mapping provider for the given mapping key + */ + OrmAttributeMappingProvider getOrmAttributeMappingProvider(String mappingKey); } diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/DefaultJavaAttributeMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/DefaultJavaAttributeMappingProvider.java deleted file mode 100644 index 43f3700ba4..0000000000 --- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/DefaultJavaAttributeMappingProvider.java +++ /dev/null @@ -1,32 +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.context.java; - - -/** - * Map a string key to an attribute mapping and its corresponding - * Java annotation adapter. - * - * Provisional API: This interface is part of an interim API that is still - * under development and expected to change significantly before reaching - * stability. It is available at this early stage to solicit feedback from - * pioneering adopters on the understanding that any code that uses this API - * will almost certainly be broken (repeatedly) as the API evolves. - */ -public interface DefaultJavaAttributeMappingProvider extends JavaAttributeMappingProvider { - - /** - * Given the IJavaPersistentAttribute return whether the default mapping applies. - * This will be used to determine the default mapping in the case where no - * mapping has been specified. - */ - boolean defaultApplies(JavaPersistentAttribute persistentAttribute); - -} diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaAttributeMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaAttributeMappingProvider.java index 76a04ed3a9..1c10bfdf78 100644 --- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaAttributeMappingProvider.java +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaAttributeMappingProvider.java @@ -21,23 +21,34 @@ import org.eclipse.jpt.core.JpaFactory; * pioneering adopters on the understanding that any code that uses this API * will almost certainly be broken (repeatedly) as the API evolves. */ -public interface JavaAttributeMappingProvider { - +public interface JavaAttributeMappingProvider +{ /** * Return the attribute mapping's key. */ String getKey(); - + /** * Return the attribute mapping's Java annotation name. */ String getAnnotationName(); - + /** * Build a Java attribute mapping for the specified attribute. Use the specified * factory for creation so extenders can simply override the appropriate * creation method instead of building a provider for the same key. */ JavaAttributeMapping buildMapping(JavaPersistentAttribute attribute, JpaFactory factory); - + + /** + * Return whether this mapping provider should be used for the given {@link JavaPersistentAttribute} + * in the default (ignoring all mapping annotations) case. + */ + boolean defaultApplies(JavaPersistentAttribute persistentAttribute); + + /** + * Return whether this mapping provider should be used for the given {@link JavaPersistentAttribute} + * in the specified (observing all mapping annotations) case. + */ + boolean specifiedApplies(JavaPersistentAttribute persistentAttribute); } diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/NullDefaultJavaAttributeMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/NullDefaultJavaAttributeMappingProvider.java new file mode 100644 index 0000000000..fe1e627bda --- /dev/null +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/NullDefaultJavaAttributeMappingProvider.java @@ -0,0 +1,71 @@ +/******************************************************************************* + * Copyright (c) 2009 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.context.java; + +import org.eclipse.jpt.core.JpaFactory; +import org.eclipse.jpt.core.MappingKeys; + +/** + * This mapping provider implementation is used to describe the default mapping for + * a java attribute when no other mapping applies. + */ +public class NullDefaultJavaAttributeMappingProvider + implements JavaAttributeMappingProvider +{ + // singleton + private static final NullDefaultJavaAttributeMappingProvider INSTANCE = + new NullDefaultJavaAttributeMappingProvider(); + + + /** + * Return the singleton. + */ + public static JavaAttributeMappingProvider instance() { + return INSTANCE; + } + + + /** + * Enforce singleton usage + */ + private NullDefaultJavaAttributeMappingProvider() { + super(); + } + + + public String getKey() { + return MappingKeys.NULL_ATTRIBUTE_MAPPING_KEY; + } + + public String getAnnotationName() { + return null; + } + + /** + * Default mappings should never be null + */ + public JavaAttributeMapping buildMapping(JavaPersistentAttribute parent, JpaFactory factory) { + return factory.buildJavaNullAttributeMapping(parent); + } + + /** + * This is typically the final test, so it should always apply + */ + public boolean defaultApplies(JavaPersistentAttribute persistentAttribute) { + return true; + } + + /** + * Obviously, always false + */ + public boolean specifiedApplies(JavaPersistentAttribute persistentAttribute) { + return false; + } +} diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaNullTypeMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/NullJavaTypeMappingProvider.java index 94cfde7742..aec6fb2cc7 100644 --- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaNullTypeMappingProvider.java +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/NullJavaTypeMappingProvider.java @@ -7,12 +7,9 @@ * Contributors: * Oracle - initial API and implementation ******************************************************************************/ -package org.eclipse.jpt.core.internal.context.java; +package org.eclipse.jpt.core.context.java; import org.eclipse.jpt.core.JpaFactory; -import org.eclipse.jpt.core.context.java.JavaPersistentType; -import org.eclipse.jpt.core.context.java.JavaTypeMapping; -import org.eclipse.jpt.core.context.java.JavaTypeMappingProvider; import org.eclipse.jpt.utility.internal.StringTools; /** @@ -20,31 +17,33 @@ import org.eclipse.jpt.utility.internal.StringTools; * A JavaNullAttributeMapping should be used when no "mapping" annotation * exists on a Java type. */ -public class JavaNullTypeMappingProvider +public class NullJavaTypeMappingProvider implements JavaTypeMappingProvider { - // singleton - private static final JavaNullTypeMappingProvider INSTANCE = new JavaNullTypeMappingProvider(); - + private static final NullJavaTypeMappingProvider INSTANCE = new NullJavaTypeMappingProvider(); + + /** * Return the singleton. */ public static JavaTypeMappingProvider instance() { return INSTANCE; } - + + /** - * Ensure single instance. + * Enforce singleton usage */ - private JavaNullTypeMappingProvider() { + private NullJavaTypeMappingProvider() { super(); } - + + public String getKey() { return null; } - + public String getAnnotationName() { return null; } @@ -52,10 +51,9 @@ public class JavaNullTypeMappingProvider public JavaTypeMapping buildMapping(JavaPersistentType parent, JpaFactory factory) { return factory.buildJavaNullTypeMapping(parent); } - + @Override public String toString() { return StringTools.buildToStringFor(this, this.getAnnotationName()); } - } diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/NullSpecifiedJavaAttributeMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/NullSpecifiedJavaAttributeMappingProvider.java new file mode 100644 index 0000000000..a36b941c17 --- /dev/null +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/NullSpecifiedJavaAttributeMappingProvider.java @@ -0,0 +1,71 @@ +/******************************************************************************* + * Copyright (c) 2009 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.context.java; + +import org.eclipse.jpt.core.JpaFactory; +import org.eclipse.jpt.core.MappingKeys; + +/** + * This mapping provider implementation is used to describe the specified mapping for + * a java attribute when no other mapping applies. + */ +public class NullSpecifiedJavaAttributeMappingProvider + implements JavaAttributeMappingProvider +{ + // singleton + private static final NullSpecifiedJavaAttributeMappingProvider INSTANCE = + new NullSpecifiedJavaAttributeMappingProvider(); + + + /** + * Return the singleton. + */ + public static JavaAttributeMappingProvider instance() { + return INSTANCE; + } + + + /** + * Enforce singleton usage + */ + private NullSpecifiedJavaAttributeMappingProvider() { + super(); + } + + + public String getKey() { + return MappingKeys.NULL_ATTRIBUTE_MAPPING_KEY; + } + + public String getAnnotationName() { + return null; + } + + /** + * There is no specified mapping in this case, attributes should revert to the default + */ + public JavaAttributeMapping buildMapping(JavaPersistentAttribute parent, JpaFactory factory) { + return null; + } + + /** + * Obviously false + */ + public boolean defaultApplies(JavaPersistentAttribute persistentAttribute) { + return false; + } + + /** + * This is typically the final test, so it should always apply + */ + public boolean specifiedApplies(JavaPersistentAttribute persistentAttribute) { + return true; + } +} diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/NullOrmAttributeMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/NullOrmAttributeMappingProvider.java new file mode 100644 index 0000000000..22fc56fd0e --- /dev/null +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/orm/NullOrmAttributeMappingProvider.java @@ -0,0 +1,63 @@ +/******************************************************************************* + * Copyright (c) 2007, 2009 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.context.orm; + +import org.eclipse.core.runtime.content.IContentType; +import org.eclipse.jpt.core.JpaFactory; +import org.eclipse.jpt.core.JptCorePlugin; +import org.eclipse.jpt.core.MappingKeys; +import org.eclipse.jpt.core.context.java.JavaAttributeMapping; +import org.eclipse.jpt.core.resource.orm.XmlAttributeMapping; +import org.eclipse.jpt.core.resource.orm.XmlNullAttributeMapping; + +public class NullOrmAttributeMappingProvider + implements OrmAttributeMappingProvider +{ + // singleton + private static final OrmAttributeMappingProvider INSTANCE = + new NullOrmAttributeMappingProvider(); + + + /** + * Return the singleton. + */ + public static OrmAttributeMappingProvider instance() { + return INSTANCE; + } + + + /** + * Enforce singleton usage + */ + private NullOrmAttributeMappingProvider() { + super(); + } + + + public IContentType getContentType() { + return JptCorePlugin.ORM_XML_CONTENT_TYPE; + } + + public String getKey() { + return MappingKeys.NULL_ATTRIBUTE_MAPPING_KEY; + } + + public XmlAttributeMapping buildResourceMapping() { + throw new UnsupportedOperationException(); + } + + public OrmAttributeMapping buildMapping(OrmPersistentAttribute parent, XmlAttributeMapping resourceMapping, JpaFactory factory) { + return factory.buildOrmNullAttributeMapping(parent, (XmlNullAttributeMapping) resourceMapping); + } + + public XmlAttributeMapping buildVirtualResourceMapping(OrmTypeMapping ormTypeMapping, JavaAttributeMapping javaAttributeMapping, JpaFactory factory) { + return factory.buildVirtualXmlNullAttributeMapping(ormTypeMapping, javaAttributeMapping); + } +} diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/GenericMappingFileProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/GenericMappingFileProvider.java deleted file mode 100644 index e50ac92b92..0000000000 --- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/GenericMappingFileProvider.java +++ /dev/null @@ -1,48 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2008, 2009 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; - -import org.eclipse.core.runtime.content.IContentType; -import org.eclipse.jpt.core.JpaFactory; -import org.eclipse.jpt.core.JptCorePlugin; -import org.eclipse.jpt.core.context.MappingFile; -import org.eclipse.jpt.core.context.MappingFileProvider; -import org.eclipse.jpt.core.context.persistence.MappingFileRef; -import org.eclipse.jpt.core.resource.xml.JpaXmlResource; - -public class GenericMappingFileProvider - implements MappingFileProvider -{ - // singleton - private static final MappingFileProvider INSTANCE = new GenericMappingFileProvider(); - - /** - * Return the singleton. - */ - public static MappingFileProvider instance() { - return INSTANCE; - } - - /** - * Ensure single instance. - */ - private GenericMappingFileProvider() { - super(); - } - - public IContentType getContentType() { - return JptCorePlugin.ORM_XML_CONTENT_TYPE; - } - - public MappingFile buildMappingFile(MappingFileRef parent, JpaXmlResource resource, JpaFactory factory) { - return factory.buildMappingFile(parent, resource); - } - -} diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaAttributeMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaAttributeMappingProvider.java new file mode 100644 index 0000000000..ceff9b1d50 --- /dev/null +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaAttributeMappingProvider.java @@ -0,0 +1,36 @@ +/******************************************************************************* + * Copyright (c) 2009 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 org.eclipse.jpt.core.context.java.JavaAttributeMappingProvider; +import org.eclipse.jpt.core.context.java.JavaPersistentAttribute; + +public abstract class AbstractJavaAttributeMappingProvider + implements JavaAttributeMappingProvider +{ + protected AbstractJavaAttributeMappingProvider() { + super(); + } + + /** + * Default implementation. Override if the mapping provider ever applies in the default case. + */ + public boolean defaultApplies(JavaPersistentAttribute persistentAttribute) { + return false; + } + + /** + * Default implementation. Override if the mapping provider needs to do more analysis. + */ + public boolean specifiedApplies(JavaPersistentAttribute persistentAttribute) { + return persistentAttribute.getResourcePersistentAttribute().getMappingAnnotation(getAnnotationName()) + != null; + } +} diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaPersistentAttribute.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaPersistentAttribute.java index c3cb67a6eb..fbba2e0b23 100644 --- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaPersistentAttribute.java +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaPersistentAttribute.java @@ -11,7 +11,6 @@ package org.eclipse.jpt.core.internal.context.java; import java.util.Iterator; import java.util.List; - import org.eclipse.core.runtime.content.IContentType; import org.eclipse.jdt.core.dom.CompilationUnit; import org.eclipse.jdt.core.dom.Modifier; @@ -22,6 +21,7 @@ import org.eclipse.jpt.core.context.Embeddable; import org.eclipse.jpt.core.context.PersistentType; import org.eclipse.jpt.core.context.TypeMapping; import org.eclipse.jpt.core.context.java.JavaAttributeMapping; +import org.eclipse.jpt.core.context.java.JavaAttributeMappingProvider; import org.eclipse.jpt.core.context.java.JavaPersistentAttribute; import org.eclipse.jpt.core.context.java.JavaStructureNodes; import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages; @@ -56,9 +56,9 @@ public abstract class AbstractJavaPersistentAttribute protected AbstractJavaPersistentAttribute(PersistentType parent, JavaResourcePersistentAttribute resourcePersistentAttribute) { super(parent); this.resourcePersistentAttribute = resourcePersistentAttribute; - this.name = this.buildName(); - this.defaultMapping = this.buildDefaultMapping(); - this.specifiedMapping = this.buildJavaAttributeMappingFromAnnotation(this.getJavaMappingAnnotationName()); + this.name = buildName(); + this.defaultMapping = buildDefaultMapping(); + this.specifiedMapping = buildSpecifiedMapping(); } @@ -374,6 +374,7 @@ public abstract class AbstractJavaPersistentAttribute return this.getMapping().getKey(); } + // ***** default mapping public JavaAttributeMapping getDefaultMapping() { return this.defaultMapping; @@ -389,12 +390,19 @@ public abstract class AbstractJavaPersistentAttribute } protected JavaAttributeMapping buildDefaultMapping() { - JavaAttributeMapping mapping = this.getJpaPlatform().buildDefaultJavaAttributeMapping(this); - Annotation annotation = this.resourcePersistentAttribute.getNullMappingAnnotation(mapping.getAnnotationName()); + JavaAttributeMappingProvider mappingProvider = + getJpaPlatform().getDefaultJavaAttributeMappingProvider(this); + return buildDefaultMapping(mappingProvider); + } + + protected JavaAttributeMapping buildDefaultMapping(JavaAttributeMappingProvider mappingProvider) { + Annotation annotation = + this.resourcePersistentAttribute.getNullMappingAnnotation(mappingProvider.getAnnotationName()); + JavaAttributeMapping mapping = mappingProvider.buildMapping(this, getJpaFactory()); mapping.initialize(annotation); return mapping; } - + /** * return null if there is no "default" mapping for the attribute */ @@ -424,8 +432,29 @@ public abstract class AbstractJavaPersistentAttribute this.firePropertyChanged(SPECIFIED_MAPPING_PROPERTY, old, specifiedMapping); } + protected JavaAttributeMapping buildSpecifiedMapping() { + JavaAttributeMappingProvider mappingProvider = + getJpaPlatform().getSpecifiedJavaAttributeMappingProvider(this); + return buildSpecifiedMapping(mappingProvider); + } + + protected JavaAttributeMapping buildSpecifiedMapping(JavaAttributeMappingProvider mappingProvider) { + if (mappingProvider == null) { + return null; + } + Annotation annotation = + this.resourcePersistentAttribute.getMappingAnnotation(mappingProvider.getAnnotationName()); + JavaAttributeMapping mapping = mappingProvider.buildMapping(this, getJpaFactory()); + // specified mappings may be null + if (mapping != null) { + mapping.initialize(annotation); + } + return mapping; + } + /** - * return null if there is no "specified" mapping for the attribute + * return the key of the currently specified mapping or null + * if there is no specified mapping for the attribute */ protected String getSpecifiedMappingKey() { return (this.specifiedMapping == null) ? null : this.specifiedMapping.getKey(); @@ -454,12 +483,18 @@ public abstract class AbstractJavaPersistentAttribute } } } - + + /** + * return the annotation name of the currently specified mapping or null + * if there is no specified mapping for the attribute + */ + protected String getSpecifiedMappingAnnotationName() { + return (this.specifiedMapping == null) ? null : this.specifiedMapping.getAnnotationName(); + } + protected JavaAttributeMapping buildMappingFromMappingKey(String key) { - if (key == MappingKeys.NULL_ATTRIBUTE_MAPPING_KEY) { - return null; - } - JavaAttributeMapping mapping = this.getJpaPlatform().buildJavaAttributeMappingFromMappingKey(key, this); + JavaAttributeMappingProvider mappingProvider = getJpaPlatform().getSpecifiedJavaAttributeMappingProvider(key); + JavaAttributeMapping mapping = mappingProvider.buildMapping(this, getJpaFactory()); //no mapping.initialize(JavaResourcePersistentAttribute) call here //we do not yet have a mapping annotation so we can't call initialize return mapping; @@ -480,46 +515,37 @@ public abstract class AbstractJavaPersistentAttribute } protected void updateDefaultMapping() { - String defaultMappingKey = this.getJpaPlatform().getDefaultJavaAttributeMappingKey(this); - if (this.defaultMapping.getKey() == defaultMappingKey) { - this.defaultMapping.update(this.resourcePersistentAttribute.getNullMappingAnnotation(this.defaultMapping.getAnnotationName())); - } else { - JavaAttributeMapping old = this.defaultMapping; - this.defaultMapping = this.buildDefaultMapping(); - this.firePropertyChanged(DEFAULT_MAPPING_PROPERTY, old, this.defaultMapping); + // There will always be a mapping provider, even if it is a "null" mapping provider ... + JavaAttributeMappingProvider mappingProvider = + getJpaPlatform().getDefaultJavaAttributeMappingProvider(this); + String mappingKey = mappingProvider.getKey(); + if (this.defaultMapping.getKey() == mappingKey) { + this.defaultMapping.update( + this.resourcePersistentAttribute.getNullMappingAnnotation( + mappingProvider.getAnnotationName())); + } + else { + setDefaultMapping(buildDefaultMapping(mappingProvider)); } } protected void updateSpecifiedMapping() { - String javaMappingAnnotationName = this.getJavaMappingAnnotationName(); - if (javaMappingAnnotationName == this.getSpecifiedMappingAnnotationName()) { - if (this.specifiedMapping != null) { - this.specifiedMapping.update(this.resourcePersistentAttribute.getMappingAnnotation(javaMappingAnnotationName)); - } - } else { - this.setSpecifiedMapping(this.buildJavaAttributeMappingFromAnnotation(javaMappingAnnotationName)); + // There may not be a mapping provider ... + JavaAttributeMappingProvider mappingProvider = + getJpaPlatform().getSpecifiedJavaAttributeMappingProvider(this); + // ... so there may not be a mapping annotation name + String annotationName = (mappingProvider == null) ? null : mappingProvider.getAnnotationName(); + if (this.specifiedMapping != null + && this.specifiedMapping.getAnnotationName().equals(annotationName)) { + this.specifiedMapping.update( + this.resourcePersistentAttribute.getMappingAnnotation(annotationName)); + } + else { + setSpecifiedMapping(buildSpecifiedMapping(mappingProvider)); } } - - protected String getJavaMappingAnnotationName() { - Annotation mappingAnnotation = this.resourcePersistentAttribute.getMappingAnnotation(); - return (mappingAnnotation == null) ? null : mappingAnnotation.getAnnotationName(); - } - - protected String getSpecifiedMappingAnnotationName() { - return (this.specifiedMapping == null) ? null : this.specifiedMapping.getAnnotationName(); - } - - protected JavaAttributeMapping buildJavaAttributeMappingFromAnnotation(String annotationName) { - if (annotationName == null) { - return null; - } - JavaAttributeMapping mapping = getJpaPlatform().buildJavaAttributeMappingFromAnnotation(annotationName, this); - mapping.initialize(this.resourcePersistentAttribute.getMappingAnnotation(annotationName)); - return mapping; - } - - + + // ********** validation ********** public TextRange getValidationTextRange(CompilationUnit astRoot) { diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaBasicMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaBasicMappingProvider.java index db6890c12a..ac1b162b0d 100644 --- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaBasicMappingProvider.java +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaBasicMappingProvider.java @@ -11,32 +11,35 @@ package org.eclipse.jpt.core.internal.context.java; import org.eclipse.jpt.core.JpaFactory; import org.eclipse.jpt.core.MappingKeys; -import org.eclipse.jpt.core.context.java.DefaultJavaAttributeMappingProvider; import org.eclipse.jpt.core.context.java.JavaAttributeMapping; +import org.eclipse.jpt.core.context.java.JavaAttributeMappingProvider; import org.eclipse.jpt.core.context.java.JavaPersistentAttribute; import org.eclipse.jpt.core.resource.java.BasicAnnotation; public class JavaBasicMappingProvider - implements DefaultJavaAttributeMappingProvider + extends AbstractJavaAttributeMappingProvider { - // singleton - private static final JavaBasicMappingProvider INSTANCE = new JavaBasicMappingProvider(); - + private static final JavaBasicMappingProvider INSTANCE = + new JavaBasicMappingProvider(); + + /** * Return the singleton. */ - public static DefaultJavaAttributeMappingProvider instance() { + public static JavaAttributeMappingProvider instance() { return INSTANCE; } - + + /** - * Ensure single instance. + * Enforce singleton usage */ private JavaBasicMappingProvider() { super(); } - + + public String getKey() { return MappingKeys.BASIC_ATTRIBUTE_MAPPING_KEY; } @@ -44,13 +47,13 @@ public class JavaBasicMappingProvider public String getAnnotationName() { return BasicAnnotation.ANNOTATION_NAME; } - + public JavaAttributeMapping buildMapping(JavaPersistentAttribute parent, JpaFactory factory) { return factory.buildJavaBasicMapping(parent); } + @Override public boolean defaultApplies(JavaPersistentAttribute persistentAttribute) { return persistentAttribute.typeIsBasic(); } - } diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaEmbeddedIdMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaEmbeddedIdMappingProvider.java index cd1cd96259..db1f455666 100644 --- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaEmbeddedIdMappingProvider.java +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaEmbeddedIdMappingProvider.java @@ -11,32 +11,35 @@ package org.eclipse.jpt.core.internal.context.java; import org.eclipse.jpt.core.JpaFactory; import org.eclipse.jpt.core.MappingKeys; -import org.eclipse.jpt.core.context.java.DefaultJavaAttributeMappingProvider; import org.eclipse.jpt.core.context.java.JavaAttributeMapping; +import org.eclipse.jpt.core.context.java.JavaAttributeMappingProvider; import org.eclipse.jpt.core.context.java.JavaPersistentAttribute; import org.eclipse.jpt.core.resource.java.EmbeddedIdAnnotation; public class JavaEmbeddedIdMappingProvider - implements DefaultJavaAttributeMappingProvider + extends AbstractJavaAttributeMappingProvider { - // singleton - private static final JavaEmbeddedIdMappingProvider INSTANCE = new JavaEmbeddedIdMappingProvider(); - + private static final JavaEmbeddedIdMappingProvider INSTANCE = + new JavaEmbeddedIdMappingProvider(); + + /** * Return the singleton. */ - public static DefaultJavaAttributeMappingProvider instance() { + public static JavaAttributeMappingProvider instance() { return INSTANCE; } - + + /** - * Ensure single instance. + * Enforce singletong usage */ private JavaEmbeddedIdMappingProvider() { super(); } - + + public String getKey() { return MappingKeys.EMBEDDED_ID_ATTRIBUTE_MAPPING_KEY; } @@ -44,12 +47,8 @@ public class JavaEmbeddedIdMappingProvider public String getAnnotationName() { return EmbeddedIdAnnotation.ANNOTATION_NAME; } - + public JavaAttributeMapping buildMapping(JavaPersistentAttribute parent, JpaFactory factory) { return factory.buildJavaEmbeddedIdMapping(parent); } - - public boolean defaultApplies(JavaPersistentAttribute persistentAttribute) { - return persistentAttribute.getEmbeddable() != null; - } } diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaEmbeddedMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaEmbeddedMappingProvider.java index 47335e3158..696f2687e5 100644 --- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaEmbeddedMappingProvider.java +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaEmbeddedMappingProvider.java @@ -11,32 +11,35 @@ package org.eclipse.jpt.core.internal.context.java; import org.eclipse.jpt.core.JpaFactory; import org.eclipse.jpt.core.MappingKeys; -import org.eclipse.jpt.core.context.java.DefaultJavaAttributeMappingProvider; import org.eclipse.jpt.core.context.java.JavaAttributeMapping; +import org.eclipse.jpt.core.context.java.JavaAttributeMappingProvider; import org.eclipse.jpt.core.context.java.JavaPersistentAttribute; import org.eclipse.jpt.core.resource.java.EmbeddedAnnotation; public class JavaEmbeddedMappingProvider - implements DefaultJavaAttributeMappingProvider + extends AbstractJavaAttributeMappingProvider { - // singleton - private static final JavaEmbeddedMappingProvider INSTANCE = new JavaEmbeddedMappingProvider(); - + private static final JavaEmbeddedMappingProvider INSTANCE = + new JavaEmbeddedMappingProvider(); + + /** * Return the singleton. */ - public static DefaultJavaAttributeMappingProvider instance() { + public static JavaAttributeMappingProvider instance() { return INSTANCE; } - + + /** - * Ensure single instance. + * Enforce singleton usage */ private JavaEmbeddedMappingProvider() { super(); } - + + public String getKey() { return MappingKeys.EMBEDDED_ATTRIBUTE_MAPPING_KEY; } @@ -44,11 +47,12 @@ public class JavaEmbeddedMappingProvider public String getAnnotationName() { return EmbeddedAnnotation.ANNOTATION_NAME; } - + public JavaAttributeMapping buildMapping(JavaPersistentAttribute parent, JpaFactory factory) { return factory.buildJavaEmbeddedMapping(parent); } + @Override public boolean defaultApplies(JavaPersistentAttribute persistentAttribute) { return persistentAttribute.getEmbeddable() != null; } diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaIdMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaIdMappingProvider.java index 013f5eed1e..307a73b328 100644 --- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaIdMappingProvider.java +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaIdMappingProvider.java @@ -17,26 +17,29 @@ import org.eclipse.jpt.core.context.java.JavaPersistentAttribute; import org.eclipse.jpt.core.resource.java.IdAnnotation; public class JavaIdMappingProvider - implements JavaAttributeMappingProvider + extends AbstractJavaAttributeMappingProvider { - // singleton - private static final JavaIdMappingProvider INSTANCE = new JavaIdMappingProvider(); - + private static final JavaIdMappingProvider INSTANCE = + new JavaIdMappingProvider(); + + /** * Return the singleton. */ public static JavaAttributeMappingProvider instance() { return INSTANCE; } - + + /** - * Ensure single instance. + * Enforce singleton usage */ private JavaIdMappingProvider() { super(); } - + + public String getKey() { return MappingKeys.ID_ATTRIBUTE_MAPPING_KEY; } diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaManyToManyMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaManyToManyMappingProvider.java index 9b540d2293..a52bc7c516 100644 --- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaManyToManyMappingProvider.java +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaManyToManyMappingProvider.java @@ -17,26 +17,29 @@ import org.eclipse.jpt.core.context.java.JavaPersistentAttribute; import org.eclipse.jpt.core.resource.java.ManyToManyAnnotation; public class JavaManyToManyMappingProvider - implements JavaAttributeMappingProvider + extends AbstractJavaAttributeMappingProvider { - // singleton - private static final JavaManyToManyMappingProvider INSTANCE = new JavaManyToManyMappingProvider(); - + private static final JavaManyToManyMappingProvider INSTANCE = + new JavaManyToManyMappingProvider(); + + /** * Return the singleton. */ public static JavaAttributeMappingProvider instance() { return INSTANCE; } - + + /** - * Ensure single instance. + * Enforce singleton usage */ private JavaManyToManyMappingProvider() { super(); } - + + public String getKey() { return MappingKeys.MANY_TO_MANY_ATTRIBUTE_MAPPING_KEY; } diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaManyToOneMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaManyToOneMappingProvider.java index dd1b262211..825483e64d 100644 --- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaManyToOneMappingProvider.java +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaManyToOneMappingProvider.java @@ -17,26 +17,29 @@ import org.eclipse.jpt.core.context.java.JavaPersistentAttribute; import org.eclipse.jpt.core.resource.java.ManyToOneAnnotation; public class JavaManyToOneMappingProvider - implements JavaAttributeMappingProvider + extends AbstractJavaAttributeMappingProvider { - // singleton - private static final JavaManyToOneMappingProvider INSTANCE = new JavaManyToOneMappingProvider(); - + private static final JavaManyToOneMappingProvider INSTANCE = + new JavaManyToOneMappingProvider(); + + /** * Return the singleton. */ public static JavaAttributeMappingProvider instance() { return INSTANCE; } - + + /** - * Ensure single instance. + * Enforce singleton usage */ private JavaManyToOneMappingProvider() { super(); } - + + public String getKey() { return MappingKeys.MANY_TO_ONE_ATTRIBUTE_MAPPING_KEY; } @@ -44,7 +47,7 @@ public class JavaManyToOneMappingProvider public String getAnnotationName() { return ManyToOneAnnotation.ANNOTATION_NAME; } - + public JavaAttributeMapping buildMapping(JavaPersistentAttribute parent, JpaFactory factory) { return factory.buildJavaManyToOneMapping(parent); } diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaNullAttributeMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaNullAttributeMappingProvider.java deleted file mode 100644 index 290cab10d8..0000000000 --- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaNullAttributeMappingProvider.java +++ /dev/null @@ -1,54 +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 org.eclipse.jpt.core.JpaFactory; -import org.eclipse.jpt.core.context.java.JavaAttributeMapping; -import org.eclipse.jpt.core.context.java.JavaAttributeMappingProvider; -import org.eclipse.jpt.core.context.java.JavaPersistentAttribute; - -/** - * This mapping provider implementation is used to create a JavaNullAttributeMapping. - * A JavaNullAttributeMapping should be used when no "mapping" annotation - * exists on a Java attribute *and* no default mapping applies. - */ -public class JavaNullAttributeMappingProvider - implements JavaAttributeMappingProvider -{ - - // singleton - private static final JavaNullAttributeMappingProvider INSTANCE = new JavaNullAttributeMappingProvider(); - - /** - * Return the singleton. - */ - public static JavaAttributeMappingProvider instance() { - return INSTANCE; - } - - /** - * Ensure single instance. - */ - private JavaNullAttributeMappingProvider() { - super(); - } - - public String getKey() { - return null; - } - - public String getAnnotationName() { - return null; - } - - public JavaAttributeMapping buildMapping(JavaPersistentAttribute parent, JpaFactory factory) { - return factory.buildJavaNullAttributeMapping(parent); - } -} diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaOneToManyMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaOneToManyMappingProvider.java index 0fa0f8e7ca..4c6c9cd747 100644 --- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaOneToManyMappingProvider.java +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaOneToManyMappingProvider.java @@ -17,26 +17,29 @@ import org.eclipse.jpt.core.context.java.JavaPersistentAttribute; import org.eclipse.jpt.core.resource.java.OneToManyAnnotation; public class JavaOneToManyMappingProvider - implements JavaAttributeMappingProvider + extends AbstractJavaAttributeMappingProvider { - // singleton - private static final JavaOneToManyMappingProvider INSTANCE = new JavaOneToManyMappingProvider(); - + private static final JavaOneToManyMappingProvider INSTANCE = + new JavaOneToManyMappingProvider(); + + /** * Return the singleton. */ public static JavaAttributeMappingProvider instance() { return INSTANCE; } - + + /** - * Ensure single instance. + * Enforce singletong usage */ private JavaOneToManyMappingProvider() { super(); } - + + public String getKey() { return MappingKeys.ONE_TO_MANY_ATTRIBUTE_MAPPING_KEY; } @@ -44,7 +47,7 @@ public class JavaOneToManyMappingProvider public String getAnnotationName() { return OneToManyAnnotation.ANNOTATION_NAME; } - + public JavaAttributeMapping buildMapping(JavaPersistentAttribute parent, JpaFactory factory) { return factory.buildJavaOneToManyMapping(parent); } diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaOneToOneMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaOneToOneMappingProvider.java index ed3215ef46..823285c5a7 100644 --- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaOneToOneMappingProvider.java +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaOneToOneMappingProvider.java @@ -17,26 +17,29 @@ import org.eclipse.jpt.core.context.java.JavaPersistentAttribute; import org.eclipse.jpt.core.resource.java.OneToOneAnnotation; public class JavaOneToOneMappingProvider - implements JavaAttributeMappingProvider + extends AbstractJavaAttributeMappingProvider { - // singleton - private static final JavaOneToOneMappingProvider INSTANCE = new JavaOneToOneMappingProvider(); - + private static final JavaOneToOneMappingProvider INSTANCE = + new JavaOneToOneMappingProvider(); + + /** * Return the singleton. */ public static JavaAttributeMappingProvider instance() { return INSTANCE; } - + + /** - * Ensure single instance. + * Enforce singleton usage */ private JavaOneToOneMappingProvider() { super(); } - + + public String getKey() { return MappingKeys.ONE_TO_ONE_ATTRIBUTE_MAPPING_KEY; } @@ -44,7 +47,7 @@ public class JavaOneToOneMappingProvider public String getAnnotationName() { return OneToOneAnnotation.ANNOTATION_NAME; } - + public JavaAttributeMapping buildMapping(JavaPersistentAttribute parent, JpaFactory factory) { return factory.buildJavaOneToOneMapping(parent); } diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaTransientMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaTransientMappingProvider.java index ebb98f5c7a..b5fcaf3bbd 100644 --- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaTransientMappingProvider.java +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaTransientMappingProvider.java @@ -17,26 +17,29 @@ import org.eclipse.jpt.core.context.java.JavaPersistentAttribute; import org.eclipse.jpt.core.resource.java.TransientAnnotation; public class JavaTransientMappingProvider - implements JavaAttributeMappingProvider + extends AbstractJavaAttributeMappingProvider { - // singleton - private static final JavaTransientMappingProvider INSTANCE = new JavaTransientMappingProvider(); - + private static final JavaTransientMappingProvider INSTANCE = + new JavaTransientMappingProvider(); + + /** * Return the singleton. */ public static JavaAttributeMappingProvider instance() { return INSTANCE; } - + + /** - * Ensure single instance. + * Enforce singleton usage */ private JavaTransientMappingProvider() { super(); } - + + public String getKey() { return MappingKeys.TRANSIENT_ATTRIBUTE_MAPPING_KEY; } diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaVersionMappingProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaVersionMappingProvider.java index 78442c9274..412dbc9def 100644 --- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaVersionMappingProvider.java +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/JavaVersionMappingProvider.java @@ -17,26 +17,29 @@ import org.eclipse.jpt.core.context.java.JavaPersistentAttribute; import org.eclipse.jpt.core.resource.java.VersionAnnotation; public class JavaVersionMappingProvider - implements JavaAttributeMappingProvider + extends AbstractJavaAttributeMappingProvider { - // singleton - private static final JavaVersionMappingProvider INSTANCE = new JavaVersionMappingProvider(); - + private static final JavaVersionMappingProvider INSTANCE = + new JavaVersionMappingProvider(); + + /** * Return the singleton. */ public static JavaAttributeMappingProvider instance() { return INSTANCE; } - + + /** - * Ensure single instance. + * Enforce singleton usage */ private JavaVersionMappingProvider() { super(); } - + + public String getKey() { return MappingKeys.VERSION_ATTRIBUTE_MAPPING_KEY; } @@ -44,7 +47,7 @@ public class JavaVersionMappingProvider public String getAnnotationName() { return VersionAnnotation.ANNOTATION_NAME; } - + public JavaAttributeMapping buildMapping(JavaPersistentAttribute parent, JpaFactory factory) { return factory.buildJavaVersionMapping(parent); } diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractEntityMappings.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractEntityMappings.java index 7a56a1d81d..5d5e38e4b6 100644 --- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractEntityMappings.java +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractEntityMappings.java @@ -15,12 +15,12 @@ import java.util.Comparator; import java.util.Iterator; import java.util.List; import java.util.ListIterator; - import org.eclipse.core.runtime.content.IContentType; import org.eclipse.jpt.core.JpaStructureNode; import org.eclipse.jpt.core.JptCorePlugin; import org.eclipse.jpt.core.context.AccessType; import org.eclipse.jpt.core.context.Generator; +import org.eclipse.jpt.core.context.MappingFileDefinition; import org.eclipse.jpt.core.context.MappingFileRoot; import org.eclipse.jpt.core.context.PersistentType; import org.eclipse.jpt.core.context.orm.EntityMappings; @@ -32,6 +32,7 @@ import org.eclipse.jpt.core.context.orm.OrmSequenceGenerator; import org.eclipse.jpt.core.context.orm.OrmStructureNodes; import org.eclipse.jpt.core.context.orm.OrmTableGenerator; import org.eclipse.jpt.core.context.orm.OrmTypeMapping; +import org.eclipse.jpt.core.context.orm.OrmTypeMappingProvider; import org.eclipse.jpt.core.context.orm.OrmXml; import org.eclipse.jpt.core.context.orm.PersistenceUnitMetadata; import org.eclipse.jpt.core.internal.context.AbstractXmlContextNode; @@ -111,6 +112,8 @@ public abstract class AbstractEntityMappings } protected abstract PersistenceUnitMetadata buildPersistenceUnitMetadata(); + + // **************** JpaNode impl ******************************************* @Override @@ -348,7 +351,9 @@ public abstract class AbstractEntityMappings } public OrmPersistentType addPersistentType(String mappingKey, String className) { - XmlTypeMapping typeMapping = getJpaPlatform().buildOrmResourceTypeMapping(mappingKey, getContentType()); + OrmTypeMappingProvider mappingProvider = + getMappingFileDefinition().getOrmTypeMappingProvider(mappingKey); + XmlTypeMapping typeMapping = mappingProvider.buildResourceMapping(); OrmPersistentType persistentType = buildPersistentType(typeMapping); int index = insertionIndex(persistentType); this.persistentTypes.add(index, persistentType); @@ -533,6 +538,10 @@ public abstract class AbstractEntityMappings return this.getOrmXml().getContentType(); } + public MappingFileDefinition getMappingFileDefinition() { + return getJpaPlatform().getMappingFileDefinition(getContentType()); + } + // ********** initialization ********** diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmPersistentAttribute.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmPersistentAttribute.java index 1896d37d40..07f790af55 100644 --- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmPersistentAttribute.java +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmPersistentAttribute.java @@ -14,8 +14,10 @@ import org.eclipse.core.runtime.content.IContentType; import org.eclipse.jpt.core.JpaStructureNode; import org.eclipse.jpt.core.MappingKeys; import org.eclipse.jpt.core.context.AccessType; +import org.eclipse.jpt.core.context.MappingFileDefinition; import org.eclipse.jpt.core.context.java.JavaPersistentAttribute; import org.eclipse.jpt.core.context.orm.OrmAttributeMapping; +import org.eclipse.jpt.core.context.orm.OrmAttributeMappingProvider; import org.eclipse.jpt.core.context.orm.OrmPersistentAttribute; import org.eclipse.jpt.core.context.orm.OrmPersistentType; import org.eclipse.jpt.core.context.orm.OrmStructureNodes; @@ -60,7 +62,9 @@ public abstract class AbstractOrmPersistentAttribute extends AbstractXmlContextN } protected OrmAttributeMapping buildAttributeMapping(XmlAttributeMapping resourceMapping) { - return getJpaPlatform().buildOrmAttributeMappingFromMappingKey(this, resourceMapping); + OrmAttributeMappingProvider mappingProvider = + getMappingFileDefinition().getOrmAttributeMappingProvider(resourceMapping.getMappingKey()); + return mappingProvider.buildMapping(this, resourceMapping, getJpaFactory()); } public String getId() { @@ -104,7 +108,9 @@ public abstract class AbstractOrmPersistentAttribute extends AbstractXmlContextN return; } OrmAttributeMapping oldMapping = this.attributeMapping; - XmlAttributeMapping resourceAttributeMapping = getJpaPlatform().buildOrmResourceAttributeMapping(newMappingKey, getContentType()); + OrmAttributeMappingProvider mappingProvider = + getMappingFileDefinition().getOrmAttributeMappingProvider(newMappingKey); + XmlAttributeMapping resourceAttributeMapping = mappingProvider.buildResourceMapping(); this.attributeMapping = buildAttributeMapping(resourceAttributeMapping); getPersistentType().changeMapping(this, oldMapping, this.attributeMapping); @@ -180,6 +186,10 @@ public abstract class AbstractOrmPersistentAttribute extends AbstractXmlContextN public IContentType getContentType() { return this.getPersistentType().getContentType(); } + + public MappingFileDefinition getMappingFileDefinition() { + return getJpaPlatform().getMappingFileDefinition(getContentType()); + } public boolean contains(int textOffset) { if (isVirtual()) { diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmPersistentType.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmPersistentType.java index 12e07cc191..0d924690df 100644 --- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmPersistentType.java +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmPersistentType.java @@ -15,12 +15,12 @@ import java.util.Comparator; import java.util.Iterator; import java.util.List; import java.util.ListIterator; - import org.eclipse.core.runtime.content.IContentType; import org.eclipse.jpt.core.JpaStructureNode; import org.eclipse.jpt.core.JptCorePlugin; import org.eclipse.jpt.core.MappingKeys; import org.eclipse.jpt.core.context.AccessType; +import org.eclipse.jpt.core.context.MappingFileDefinition; import org.eclipse.jpt.core.context.PersistentAttribute; import org.eclipse.jpt.core.context.PersistentType; import org.eclipse.jpt.core.context.java.JavaAttributeMapping; @@ -28,10 +28,12 @@ import org.eclipse.jpt.core.context.java.JavaPersistentAttribute; import org.eclipse.jpt.core.context.java.JavaPersistentType; import org.eclipse.jpt.core.context.orm.EntityMappings; import org.eclipse.jpt.core.context.orm.OrmAttributeMapping; +import org.eclipse.jpt.core.context.orm.OrmAttributeMappingProvider; import org.eclipse.jpt.core.context.orm.OrmPersistentAttribute; import org.eclipse.jpt.core.context.orm.OrmPersistentType; import org.eclipse.jpt.core.context.orm.OrmStructureNodes; import org.eclipse.jpt.core.context.orm.OrmTypeMapping; +import org.eclipse.jpt.core.context.orm.OrmTypeMappingProvider; import org.eclipse.jpt.core.internal.context.AbstractXmlContextNode; import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages; import org.eclipse.jpt.core.internal.validation.JpaValidationMessages; @@ -99,7 +101,11 @@ public abstract class AbstractOrmPersistentType public IContentType getContentType() { return this.getEntityMappings().getContentType(); } - + + public MappingFileDefinition getMappingFileDefinition() { + return getJpaPlatform().getMappingFileDefinition(getContentType()); + } + public String getDefaultPackage() { return this.getEntityMappings().getDefaultPersistentTypePackage(); } @@ -128,13 +134,16 @@ public abstract class AbstractOrmPersistentType } protected OrmTypeMapping buildTypeMapping(XmlTypeMapping resourceMapping) { - return this.getJpaPlatform().buildOrmTypeMappingFromMappingKey(this, resourceMapping); + OrmTypeMappingProvider mappingProvider = + getMappingFileDefinition().getOrmTypeMappingProvider(resourceMapping.getMappingKey()); + return mappingProvider.buildMapping(this, resourceMapping, getJpaFactory()); } public OrmTypeMapping getMapping() { return this.typeMapping; } - + + // **************** PersistentType.Owner implementation ***************************** public AccessType getOverridePersistentTypeAccess() { @@ -180,7 +189,9 @@ public abstract class AbstractOrmPersistentType return; } OrmTypeMapping oldMapping = getMapping(); - XmlTypeMapping resourceTypeMapping = getJpaPlatform().buildOrmResourceTypeMapping(newMappingKey, getContentType()); + OrmTypeMappingProvider mappingProvider = + getMappingFileDefinition().getOrmTypeMappingProvider(newMappingKey); + XmlTypeMapping resourceTypeMapping = mappingProvider.buildResourceMapping(); this.typeMapping = buildTypeMapping(resourceTypeMapping); this.getEntityMappings().changeMapping(this, oldMapping, this.typeMapping); firePropertyChanged(MAPPING_PROPERTY, oldMapping, this.typeMapping); @@ -296,7 +307,9 @@ public abstract class AbstractOrmPersistentType getMapping().getResourceTypeMapping().setAttributes(resourceAttributes); } - XmlAttributeMapping resourceMapping = getJpaPlatform().buildOrmResourceAttributeMapping(mappingKey, getContentType()); + OrmAttributeMappingProvider mappingProvider = + getMappingFileDefinition().getOrmAttributeMappingProvider(mappingKey); + XmlAttributeMapping resourceMapping = mappingProvider.buildResourceMapping(); OrmPersistentAttribute newPersistentAttribute = buildSpecifiedOrmPersistentAttribute(resourceMapping); int insertionIndex = insertionIndex(newPersistentAttribute); @@ -430,7 +443,9 @@ public abstract class AbstractOrmPersistentType getMapping().getResourceTypeMapping().setAttributes(resourceAttributes); } - XmlAttributeMapping resourceMapping = getJpaPlatform().buildOrmResourceAttributeMapping(mappingKey, getContentType()); + OrmAttributeMappingProvider mappingProvider = + getMappingFileDefinition().getOrmAttributeMappingProvider(mappingKey); + XmlAttributeMapping resourceMapping = mappingProvider.buildResourceMapping(); OrmPersistentAttribute persistentAttribute = buildSpecifiedOrmPersistentAttribute(resourceMapping); int index = insertionIndex(persistentAttribute); this.specifiedPersistentAttributes.add(index, persistentAttribute); @@ -860,7 +875,10 @@ public abstract class AbstractOrmPersistentType //not firing change notification so this can be reused in initialize and update protected OrmPersistentAttribute addVirtualPersistentAttribute(JavaAttributeMapping javaAttributeMapping) { - XmlAttributeMapping resourceMapping = getJpaPlatform().buildVirtualOrmResourceMappingFromMappingKey(javaAttributeMapping.getKey(), getMapping(), javaAttributeMapping); + OrmAttributeMappingProvider mappingProvider = + getMappingFileDefinition().getOrmAttributeMappingProvider(javaAttributeMapping.getKey()); + XmlAttributeMapping resourceMapping = + mappingProvider.buildVirtualResourceMapping(getMapping(), javaAttributeMapping, getJpaFactory()); OrmPersistentAttribute virtualPersistentAttribute = buildVirtualOrmPersistentAttribute(javaAttributeMapping, resourceMapping); this.virtualPersistentAttributes.add(virtualPersistentAttribute); return virtualPersistentAttribute; diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmMappingFileDefinition.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmMappingFileDefinition.java new file mode 100644 index 0000000000..8169b39f6f --- /dev/null +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/GenericOrmMappingFileDefinition.java @@ -0,0 +1,88 @@ +/******************************************************************************* + * Copyright (c) 2008, 2009 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 org.eclipse.core.runtime.content.IContentType; +import org.eclipse.jpt.core.JpaFactory; +import org.eclipse.jpt.core.JptCorePlugin; +import org.eclipse.jpt.core.context.MappingFile; +import org.eclipse.jpt.core.context.MappingFileDefinition; +import org.eclipse.jpt.core.context.orm.OrmAttributeMappingProvider; +import org.eclipse.jpt.core.context.orm.OrmTypeMappingProvider; +import org.eclipse.jpt.core.context.persistence.MappingFileRef; +import org.eclipse.jpt.core.internal.platform.AbstractMappingFileDefinition; +import org.eclipse.jpt.core.resource.xml.JpaXmlResource; + +public class GenericOrmMappingFileDefinition + extends AbstractMappingFileDefinition +{ + // singleton + private static final MappingFileDefinition INSTANCE = + new GenericOrmMappingFileDefinition(); + + + /** + * Return the singleton + */ + public static MappingFileDefinition instance() { + return INSTANCE; + } + + + /** + * Enforce singleton usage + */ + private GenericOrmMappingFileDefinition() { + super(); + } + + + public IContentType getContentType() { + return JptCorePlugin.ORM_XML_CONTENT_TYPE; + } + + public MappingFile buildMappingFile(MappingFileRef parent, JpaXmlResource resource, JpaFactory factory) { + return factory.buildMappingFile(parent, resource); + } + + + // ********** ORM type mappings ********** + + @Override + protected OrmTypeMappingProvider[] buildOrmTypeMappingProviders() { + // order should not matter here, but we'll use the same order as for java + // (@see {@link GenericJpaPlatformProvider}) + return new OrmTypeMappingProvider[] { + OrmEntityProvider.instance(), + OrmEmbeddableProvider.instance(), + OrmMappedSuperclassProvider.instance()}; + } + + + // ********** ORM attribute mappings ********** + + @Override + protected OrmAttributeMappingProvider[] buildOrmAttributeMappingProviders() { + // order should not matter here, but we'll use the same order as for java + // (@see {@link GenericJpaPlatformProvider}) + return new OrmAttributeMappingProvider[] { + OrmTransientMappingProvider.instance(), + OrmIdMappingProvider.instance(), + OrmVersionMappingProvider.instance(), + OrmBasicMappingProvider.instance(), + OrmEmbeddedMappingProvider.instance(), + OrmEmbeddedIdMappingProvider.instance(), + OrmManyToManyMappingProvider.instance(), + OrmManyToOneMappingProvider.instance(), + OrmOneToManyMappingProvider.instance(), + OrmOneToOneMappingProvider.instance(), + OrmNullAttributeMappingProvider.instance()}; + } +} diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/AbstractMappingFileRef.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/AbstractMappingFileRef.java index 804ada585f..69c7338b90 100644 --- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/AbstractMappingFileRef.java +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/persistence/AbstractMappingFileRef.java @@ -14,6 +14,7 @@ import org.eclipse.core.resources.IFile; import org.eclipse.core.runtime.content.IContentType; import org.eclipse.jpt.core.JpaStructureNode; import org.eclipse.jpt.core.context.MappingFile; +import org.eclipse.jpt.core.context.MappingFileDefinition; import org.eclipse.jpt.core.context.MappingFilePersistenceUnitDefaults; import org.eclipse.jpt.core.context.MappingFileRoot; import org.eclipse.jpt.core.context.PersistentType; @@ -160,9 +161,10 @@ public abstract class AbstractMappingFileRef } protected MappingFile buildMappingFile(JpaXmlResource resource) { - return this.getJpaPlatform().buildMappingFile(this, resource); + MappingFileDefinition mappingFileDef = getJpaPlatform().getMappingFileDefinition(resource.getContentType()); + return (mappingFileDef == null) ? null : mappingFileDef.buildMappingFile(this, resource, getJpaFactory()); } - + @Override public void postUpdate() { super.postUpdate(); diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/Generic2_0MappingFileProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/Generic2_0MappingFileProvider.java deleted file mode 100644 index da7dbb2c1a..0000000000 --- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/Generic2_0MappingFileProvider.java +++ /dev/null @@ -1,49 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2009 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.jpa2.context; - -import org.eclipse.core.runtime.content.IContentType; -import org.eclipse.jpt.core.JpaFactory; -import org.eclipse.jpt.core.JptCorePlugin; -import org.eclipse.jpt.core.context.MappingFile; -import org.eclipse.jpt.core.context.MappingFileProvider; -import org.eclipse.jpt.core.context.persistence.MappingFileRef; -import org.eclipse.jpt.core.internal.jpa2.platform.Generic2_0JpaFactory; -import org.eclipse.jpt.core.resource.xml.JpaXmlResource; - -public class Generic2_0MappingFileProvider - implements MappingFileProvider -{ - // singleton - private static final MappingFileProvider INSTANCE = new Generic2_0MappingFileProvider(); - - /** - * Return the singleton. - */ - public static MappingFileProvider instance() { - return INSTANCE; - } - - /** - * Ensure single instance. - */ - private Generic2_0MappingFileProvider() { - super(); - } - - public IContentType getContentType() { - return JptCorePlugin.ORM2_0_XML_CONTENT_TYPE; - } - - public MappingFile buildMappingFile(MappingFileRef parent, JpaXmlResource resource, JpaFactory factory) { - return ((Generic2_0JpaFactory) factory).buildMappingFile2_0(parent, resource); - } - -} diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/GenericOrm2_0MappingFileDefinition.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/GenericOrm2_0MappingFileDefinition.java new file mode 100644 index 0000000000..1ad3a89e03 --- /dev/null +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/GenericOrm2_0MappingFileDefinition.java @@ -0,0 +1,104 @@ +/******************************************************************************* + * Copyright (c) 2009 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.jpa2.context; + +import org.eclipse.core.runtime.content.IContentType; +import org.eclipse.jpt.core.JpaFactory; +import org.eclipse.jpt.core.JptCorePlugin; +import org.eclipse.jpt.core.context.MappingFile; +import org.eclipse.jpt.core.context.MappingFileDefinition; +import org.eclipse.jpt.core.context.orm.OrmAttributeMappingProvider; +import org.eclipse.jpt.core.context.orm.OrmTypeMappingProvider; +import org.eclipse.jpt.core.context.persistence.MappingFileRef; +import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmBasicMapping2_0Provider; +import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmEmbeddableMapping2_0Provider; +import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmEmbeddedIdMapping2_0Provider; +import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmEmbeddedMapping2_0Provider; +import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmEntityMapping2_0Provider; +import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmIdMapping2_0Provider; +import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmManyToManyMapping2_0Provider; +import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmManyToOneMapping2_0Provider; +import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmMappedSuperclassMapping2_0Provider; +import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmNullAttributeMapping2_0Provider; +import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmOneToManyMapping2_0Provider; +import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmOneToOneMapping2_0Provider; +import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmTransientMapping2_0Provider; +import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmVersionMapping2_0Provider; +import org.eclipse.jpt.core.internal.jpa2.platform.Generic2_0JpaFactory; +import org.eclipse.jpt.core.internal.platform.AbstractMappingFileDefinition; +import org.eclipse.jpt.core.resource.xml.JpaXmlResource; + +public class GenericOrm2_0MappingFileDefinition + extends AbstractMappingFileDefinition +{ + // singleton + private static final MappingFileDefinition INSTANCE = + new GenericOrm2_0MappingFileDefinition(); + + + /** + * Return the singleton + */ + public static MappingFileDefinition instance() { + return INSTANCE; + } + + + /** + * Enforce singleton usage + */ + private GenericOrm2_0MappingFileDefinition() { + super(); + } + + + public IContentType getContentType() { + return JptCorePlugin.ORM2_0_XML_CONTENT_TYPE; + } + + public MappingFile buildMappingFile(MappingFileRef parent, JpaXmlResource resource, JpaFactory factory) { + return ((Generic2_0JpaFactory) factory).buildMappingFile2_0(parent, resource); + } + + + // ********** ORM type mappings ********** + + @Override + protected OrmTypeMappingProvider[] buildOrmTypeMappingProviders() { + // order should not matter here, but we'll use the same order as for java + // (@see {@link Generic2_0JpaPlatformProvider}) + return new OrmTypeMappingProvider[] { + GenericOrmEntityMapping2_0Provider.instance(), + GenericOrmEmbeddableMapping2_0Provider.instance(), + GenericOrmMappedSuperclassMapping2_0Provider.instance()}; + } + + + // ********** ORM attribute mappings ********** + + @Override + protected OrmAttributeMappingProvider[] buildOrmAttributeMappingProviders() { + // order should not matter here, but we'll use the same order as for java + // (@see {@link Generic2_0JpaPlatformProvider}) + return new OrmAttributeMappingProvider[] { + GenericOrmTransientMapping2_0Provider.instance(), + //OrmElementCollectionMappingProvider.instance(), + GenericOrmIdMapping2_0Provider.instance(), + GenericOrmVersionMapping2_0Provider.instance(), + GenericOrmBasicMapping2_0Provider.instance(), + GenericOrmEmbeddedMapping2_0Provider.instance(), + GenericOrmEmbeddedIdMapping2_0Provider.instance(), + GenericOrmManyToManyMapping2_0Provider.instance(), + GenericOrmManyToOneMapping2_0Provider.instance(), + GenericOrmOneToManyMapping2_0Provider.instance(), + GenericOrmOneToOneMapping2_0Provider.instance(), + GenericOrmNullAttributeMapping2_0Provider.instance()}; + } +} diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/platform/Generic2_0JpaPlatformFactory.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/platform/Generic2_0JpaPlatformFactory.java index 1c087ed4f8..4a59d42e83 100644 --- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/platform/Generic2_0JpaPlatformFactory.java +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/platform/Generic2_0JpaPlatformFactory.java @@ -9,14 +9,11 @@ ******************************************************************************/ package org.eclipse.jpt.core.internal.jpa2.platform; -import org.eclipse.jpt.core.JpaAnnotationProvider; -import org.eclipse.jpt.core.JpaFactory; import org.eclipse.jpt.core.JpaPlatform; import org.eclipse.jpt.core.JpaPlatformFactory; import org.eclipse.jpt.core.JpaValidation; import org.eclipse.jpt.core.internal.platform.GenericJpaAnnotationProvider; import org.eclipse.jpt.core.internal.platform.GenericJpaPlatform; -import org.eclipse.jpt.core.internal.platform.GenericJpaPlatformProvider; /** * All the state in the JPA platform should be "static" (i.e. unchanging once @@ -25,7 +22,6 @@ import org.eclipse.jpt.core.internal.platform.GenericJpaPlatformProvider; public class Generic2_0JpaPlatformFactory implements JpaPlatformFactory { - /** * zero-argument constructor */ @@ -33,23 +29,14 @@ public class Generic2_0JpaPlatformFactory super(); } + public JpaPlatform buildJpaPlatform(String id) { return new GenericJpaPlatform( id, - buildJpaFactory(), - buildJpaAnnotationProvider(), - buildJpaValidation(), - GenericJpaPlatformProvider.instance(), - Generic2_0JpaPlatformProvider.instance()); - } - - protected JpaFactory buildJpaFactory() { - return new Generic2_0JpaFactory(); - } - - protected JpaAnnotationProvider buildJpaAnnotationProvider() { - return new GenericJpaAnnotationProvider( - Generic2_0JpaAnnotationDefinitionProvider.instance()); + new Generic2_0JpaFactory(), + new GenericJpaAnnotationProvider(Generic2_0JpaAnnotationDefinitionProvider.instance()), + Generic2_0JpaPlatformProvider.instance(), + buildJpaValidation()); } protected JpaValidation buildJpaValidation() { diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/platform/Generic2_0JpaPlatformProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/platform/Generic2_0JpaPlatformProvider.java index 4bd935ca24..cf9cfff3e2 100644 --- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/platform/Generic2_0JpaPlatformProvider.java +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/platform/Generic2_0JpaPlatformProvider.java @@ -9,126 +9,126 @@ ******************************************************************************/ package org.eclipse.jpt.core.internal.jpa2.platform; -import java.util.List; import org.eclipse.jpt.core.JpaPlatformProvider; import org.eclipse.jpt.core.JpaResourceModelProvider; -import org.eclipse.jpt.core.context.MappingFileProvider; -import org.eclipse.jpt.core.context.java.DefaultJavaAttributeMappingProvider; +import org.eclipse.jpt.core.context.MappingFileDefinition; import org.eclipse.jpt.core.context.java.JavaAttributeMappingProvider; import org.eclipse.jpt.core.context.java.JavaTypeMappingProvider; -import org.eclipse.jpt.core.context.orm.OrmAttributeMappingProvider; -import org.eclipse.jpt.core.context.orm.OrmTypeMappingProvider; +import org.eclipse.jpt.core.internal.JarResourceModelProvider; +import org.eclipse.jpt.core.internal.JavaResourceModelProvider; +import org.eclipse.jpt.core.internal.OrmResourceModelProvider; +import org.eclipse.jpt.core.internal.PersistenceResourceModelProvider; +import org.eclipse.jpt.core.internal.context.java.JavaBasicMappingProvider; +import org.eclipse.jpt.core.internal.context.java.JavaEmbeddableProvider; +import org.eclipse.jpt.core.internal.context.java.JavaEmbeddedIdMappingProvider; +import org.eclipse.jpt.core.internal.context.java.JavaEmbeddedMappingProvider; +import org.eclipse.jpt.core.internal.context.java.JavaEntityProvider; +import org.eclipse.jpt.core.internal.context.java.JavaIdMappingProvider; +import org.eclipse.jpt.core.internal.context.java.JavaManyToManyMappingProvider; +import org.eclipse.jpt.core.internal.context.java.JavaManyToOneMappingProvider; +import org.eclipse.jpt.core.internal.context.java.JavaMappedSuperclassProvider; +import org.eclipse.jpt.core.internal.context.java.JavaOneToManyMappingProvider; +import org.eclipse.jpt.core.internal.context.java.JavaOneToOneMappingProvider; +import org.eclipse.jpt.core.internal.context.java.JavaTransientMappingProvider; +import org.eclipse.jpt.core.internal.context.java.JavaVersionMappingProvider; +import org.eclipse.jpt.core.internal.context.orm.GenericOrmMappingFileDefinition; import org.eclipse.jpt.core.internal.jpa2.Orm2_0ResourceModelProvider; import org.eclipse.jpt.core.internal.jpa2.Persistence2_0ResourceModelProvider; -import org.eclipse.jpt.core.internal.jpa2.context.Generic2_0MappingFileProvider; -import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmBasicMapping2_0Provider; -import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmEmbeddableMapping2_0Provider; -import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmEmbeddedIdMapping2_0Provider; -import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmEmbeddedMapping2_0Provider; -import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmEntityMapping2_0Provider; -import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmIdMapping2_0Provider; -import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmManyToManyMapping2_0Provider; -import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmManyToOneMapping2_0Provider; -import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmMappedSuperclassMapping2_0Provider; -import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmNullAttributeMapping2_0Provider; -import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmOneToManyMapping2_0Provider; -import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmOneToOneMapping2_0Provider; -import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmTransientMapping2_0Provider; -import org.eclipse.jpt.core.internal.jpa2.context.orm.GenericOrmVersionMapping2_0Provider; +import org.eclipse.jpt.core.internal.jpa2.context.GenericOrm2_0MappingFileDefinition; import org.eclipse.jpt.core.internal.platform.AbstractJpaPlatformProvider; /** * All the state in the JPA platform should be "static" (i.e. unchanging once * it is initialized). */ -public class Generic2_0JpaPlatformProvider extends AbstractJpaPlatformProvider +public class Generic2_0JpaPlatformProvider + extends AbstractJpaPlatformProvider { public static final String ID = "generic2_0"; //$NON-NLS-1$ - + + // singleton - private static final JpaPlatformProvider INSTANCE = new Generic2_0JpaPlatformProvider(); - + private static final JpaPlatformProvider INSTANCE = + new Generic2_0JpaPlatformProvider(); + + /** - * Return the singleton. + * Return the singleton */ public static JpaPlatformProvider instance() { return INSTANCE; } - + + /** - * Ensure single instance. + * Enforce singleton usage */ private Generic2_0JpaPlatformProvider() { super(); } - - + + // ********** resource models ********** - + @Override - protected void addResourceModelProvidersTo(List<JpaResourceModelProvider> providers) { - providers.add(Persistence2_0ResourceModelProvider.instance()); - providers.add(Orm2_0ResourceModelProvider.instance()); + protected JpaResourceModelProvider[] buildResourceModelProviders() { + // order should not be important here + return new JpaResourceModelProvider[] { + JavaResourceModelProvider.instance(), + JarResourceModelProvider.instance(), + PersistenceResourceModelProvider.instance(), + OrmResourceModelProvider.instance(), + Persistence2_0ResourceModelProvider.instance(), + Orm2_0ResourceModelProvider.instance()}; } - - + + // ********** Java type mappings ********** @Override - protected void addJavaTypeMappingProvidersTo(List<JavaTypeMappingProvider> providers) { + protected JavaTypeMappingProvider[] buildNonNullJavaTypeMappingProviders() { + // order determined by analyzing order that reference implementation (eclipselink) uses + return new JavaTypeMappingProvider[] { + JavaEntityProvider.instance(), + JavaEmbeddableProvider.instance(), + JavaMappedSuperclassProvider.instance()}; } - - + + // ********** Java attribute mappings ********** - - @Override - protected void addJavaAttributeMappingProvidersTo(List<JavaAttributeMappingProvider> providers) { - //providers.add(JavaElementCollectionMappingProvider.instance()); - } - - - // ********** default Java attribute mappings ********** - - @Override - protected void addDefaultJavaAttributeMappingProvidersTo(List<DefaultJavaAttributeMappingProvider> providers) { - } - - // ********** Mapping File ********** - - /** - * Override this to specify more or different mapping file providers. - */ + @Override - protected void addMappingFileProvidersTo(List<MappingFileProvider> providers) { - providers.add(Generic2_0MappingFileProvider.instance()); + protected JavaAttributeMappingProvider[] buildNonNullDefaultJavaAttributeMappingProviders() { + // order determined by analyzing order that reference implementation (toplink) uses + return new JavaAttributeMappingProvider[] { + JavaEmbeddedMappingProvider.instance(), + JavaBasicMappingProvider.instance()}; } - - - // ********** ORM type mappings ********** - + @Override - protected void addOrmTypeMappingProvidersTo(List<OrmTypeMappingProvider> providers) { - providers.add(GenericOrmEmbeddableMapping2_0Provider.instance()); - providers.add(GenericOrmEntityMapping2_0Provider.instance()); - providers.add(GenericOrmMappedSuperclassMapping2_0Provider.instance()); + protected JavaAttributeMappingProvider[] buildNonNullSpecifiedJavaAttributeMappingProviders() { + // order determined by analyzing order that reference implementation (toplink) uses + return new JavaAttributeMappingProvider[] { + JavaTransientMappingProvider.instance(), + //JavaElementCollectionMappingProvider.instance(), + JavaIdMappingProvider.instance(), + JavaVersionMappingProvider.instance(), + JavaBasicMappingProvider.instance(), + JavaEmbeddedMappingProvider.instance(), + JavaEmbeddedIdMappingProvider.instance(), + JavaManyToManyMappingProvider.instance(), + JavaManyToOneMappingProvider.instance(), + JavaOneToManyMappingProvider.instance(), + JavaOneToOneMappingProvider.instance()}; } - - - // ********** ORM attribute mappings ********** - + + + // ********** Mapping Files ********** + @Override - protected void addOrmAttributeMappingProvidersTo(List<OrmAttributeMappingProvider> providers) { - providers.add(GenericOrmBasicMapping2_0Provider.instance()); - providers.add(GenericOrmIdMapping2_0Provider.instance()); - //providers.add(OrmElementCollectionMappingProvider.instance()); - providers.add(GenericOrmEmbeddedIdMapping2_0Provider.instance()); - providers.add(GenericOrmEmbeddedMapping2_0Provider.instance()); - providers.add(GenericOrmManyToManyMapping2_0Provider.instance()); - providers.add(GenericOrmManyToOneMapping2_0Provider.instance()); - providers.add(GenericOrmOneToManyMapping2_0Provider.instance()); - providers.add(GenericOrmOneToOneMapping2_0Provider.instance()); - providers.add(GenericOrmVersionMapping2_0Provider.instance()); - providers.add(GenericOrmTransientMapping2_0Provider.instance()); - providers.add(GenericOrmNullAttributeMapping2_0Provider.instance()); + protected MappingFileDefinition[] buildMappingFileDefinitions() { + return new MappingFileDefinition[] { + GenericOrmMappingFileDefinition.instance(), + GenericOrm2_0MappingFileDefinition.instance()}; } } diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/AbstractJpaPlatformProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/AbstractJpaPlatformProvider.java index 69b35d35fe..0548b18f93 100644 --- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/AbstractJpaPlatformProvider.java +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/AbstractJpaPlatformProvider.java @@ -9,52 +9,46 @@ ******************************************************************************/ package org.eclipse.jpt.core.internal.platform; -import java.util.ArrayList; -import java.util.List; import java.util.ListIterator; - import org.eclipse.jpt.core.JpaPlatformProvider; import org.eclipse.jpt.core.JpaResourceModelProvider; -import org.eclipse.jpt.core.context.MappingFileProvider; -import org.eclipse.jpt.core.context.java.DefaultJavaAttributeMappingProvider; +import org.eclipse.jpt.core.context.MappingFileDefinition; import org.eclipse.jpt.core.context.java.JavaAttributeMappingProvider; +import org.eclipse.jpt.core.context.java.NullJavaTypeMappingProvider; +import org.eclipse.jpt.core.context.java.NullDefaultJavaAttributeMappingProvider; +import org.eclipse.jpt.core.context.java.NullSpecifiedJavaAttributeMappingProvider; import org.eclipse.jpt.core.context.java.JavaTypeMappingProvider; -import org.eclipse.jpt.core.context.orm.OrmAttributeMappingProvider; -import org.eclipse.jpt.core.context.orm.OrmTypeMappingProvider; -import org.eclipse.jpt.core.internal.context.java.JavaNullAttributeMappingProvider; +import org.eclipse.jpt.utility.internal.CollectionTools; import org.eclipse.jpt.utility.internal.iterators.ArrayListIterator; /** * All the state in the JPA platform should be "static" (i.e. unchanging once * it is initialized). */ -public abstract class AbstractJpaPlatformProvider implements JpaPlatformProvider +public abstract class AbstractJpaPlatformProvider + implements JpaPlatformProvider { private JpaResourceModelProvider[] resourceModelProviders; private JavaTypeMappingProvider[] javaTypeMappingProviders; - private JavaAttributeMappingProvider[] javaAttributeMappingProviders; - - private MappingFileProvider[] mappingFileProviders; - - private DefaultJavaAttributeMappingProvider[] defaultJavaAttributeMappingProviders; + private JavaAttributeMappingProvider[] specifiedJavaAttributeMappingProviders; - private OrmTypeMappingProvider[] ormTypeMappingProviders; + private JavaAttributeMappingProvider[] defaultJavaAttributeMappingProviders; - private OrmAttributeMappingProvider[] ormAttributeMappingProviders; + private MappingFileDefinition[] mappingFileDefinitions; /** * zero-argument constructor */ - public AbstractJpaPlatformProvider() { + protected AbstractJpaPlatformProvider() { super(); } // ********** resource models ********** - + public ListIterator<JpaResourceModelProvider> resourceModelProviders() { return new ArrayListIterator<JpaResourceModelProvider>(getResourceModelProviders()); } @@ -65,19 +59,10 @@ public abstract class AbstractJpaPlatformProvider implements JpaPlatformProvider } return this.resourceModelProviders; } - - protected JpaResourceModelProvider[] buildResourceModelProviders() { - ArrayList<JpaResourceModelProvider> providers = new ArrayList<JpaResourceModelProvider>(); - this.addResourceModelProvidersTo(providers); - return providers.toArray(new JpaResourceModelProvider[providers.size()]); - } - - /** - * Implement this to specify JPA resource model providers. - */ - protected abstract void addResourceModelProvidersTo(List<JpaResourceModelProvider> providers); - - + + protected abstract JpaResourceModelProvider[] buildResourceModelProviders(); + + // ********** Java type mappings ********** public ListIterator<JavaTypeMappingProvider> javaTypeMappingProviders() { @@ -90,148 +75,114 @@ public abstract class AbstractJpaPlatformProvider implements JpaPlatformProvider } return this.javaTypeMappingProviders; } - - protected JavaTypeMappingProvider[] buildJavaTypeMappingProviders() { - ArrayList<JavaTypeMappingProvider> providers = new ArrayList<JavaTypeMappingProvider>(); - this.addJavaTypeMappingProvidersTo(providers); - return providers.toArray(new JavaTypeMappingProvider[providers.size()]); - } - + /** - * Implement this to specify type mapping providers. + * Return an array of mapping providers to use for analyzing the mapping of a type given all + * annotations on it. The order is important, as once a mapping provider tests positive for an + * attribute, all following mapping providers are ignored. + * Extenders may either overwrite this method or {@link #buildNonNullJavaTypeMappingProviders()}. + * Doing the former places the additional requirement on the extender to provide a "null" + * mapping provider (@see {@link NullJavaTypeMappingProvider}.) */ - protected abstract void addJavaTypeMappingProvidersTo(List<JavaTypeMappingProvider> providers); - - - // ********** Java attribute mappings ********** - - public ListIterator<JavaAttributeMappingProvider> javaAttributeMappingProviders() { - return new ArrayListIterator<JavaAttributeMappingProvider>(getJavaAttributeMappingProviders()); + protected JavaTypeMappingProvider[] buildJavaTypeMappingProviders() { + return CollectionTools.add( + buildNonNullJavaTypeMappingProviders(), + NullJavaTypeMappingProvider.instance()); } - protected synchronized JavaAttributeMappingProvider[] getJavaAttributeMappingProviders() { - if (this.javaAttributeMappingProviders == null) { - this.javaAttributeMappingProviders = this.buildJavaAttributeMappingProviders(); - } - return this.javaAttributeMappingProviders; - } - - protected JavaAttributeMappingProvider[] buildJavaAttributeMappingProviders() { - ArrayList<JavaAttributeMappingProvider> providers = new ArrayList<JavaAttributeMappingProvider>(); - this.addJavaAttributeMappingProvidersTo(providers); - return providers.toArray(new JavaAttributeMappingProvider[providers.size()]); - } - /** - * Implement this to specify attribute mapping providers. + * No-op implementation of this method. + * @see #buildJavaTypeMappingProviders() */ - protected abstract void addJavaAttributeMappingProvidersTo(List<JavaAttributeMappingProvider> providers); - - - // ********** default Java attribute mappings ********** + protected JavaTypeMappingProvider[] buildNonNullJavaTypeMappingProviders() { + return new JavaTypeMappingProvider[0]; + } + + + // ********** Java attribute mappings ********** - public ListIterator<DefaultJavaAttributeMappingProvider> defaultJavaAttributeMappingProviders() { - return new ArrayListIterator<DefaultJavaAttributeMappingProvider>(getDefaultJavaAttributeMappingProviders()); + public ListIterator<JavaAttributeMappingProvider> defaultJavaAttributeMappingProviders() { + return new ArrayListIterator<JavaAttributeMappingProvider>(getDefaultJavaAttributeMappingProviders()); } - protected synchronized DefaultJavaAttributeMappingProvider[] getDefaultJavaAttributeMappingProviders() { + protected synchronized JavaAttributeMappingProvider[] getDefaultJavaAttributeMappingProviders() { if (this.defaultJavaAttributeMappingProviders == null) { this.defaultJavaAttributeMappingProviders = this.buildDefaultJavaAttributeMappingProviders(); } return this.defaultJavaAttributeMappingProviders; } - - protected DefaultJavaAttributeMappingProvider[] buildDefaultJavaAttributeMappingProviders() { - ArrayList<DefaultJavaAttributeMappingProvider> providers = new ArrayList<DefaultJavaAttributeMappingProvider>(); - this.addDefaultJavaAttributeMappingProvidersTo(providers); - return providers.toArray(new DefaultJavaAttributeMappingProvider[providers.size()]); - } - + /** - * Implement this to specify default attribute mapping providers. + * Return an array of mapping providers to use for analyzing the default mapping of an attribute + * in the absence of any annotations. The order is important, as once a mapping provider tests + * positively for a given attribute, all following mapping providers are ignored. + * Extenders may either overwrite this method or + * {@link #buildNonNullDefaultJavaAttributeMappingProviders()}. + * Doing the former places the additional requirement on the extender to provide a "null" + * mapping provider (@see {@link NullDefaultJavaAttributeMappingProvider}.) */ - protected abstract void addDefaultJavaAttributeMappingProvidersTo(List<DefaultJavaAttributeMappingProvider> providers); - + protected JavaAttributeMappingProvider[] buildDefaultJavaAttributeMappingProviders() { + return CollectionTools.add( + buildNonNullDefaultJavaAttributeMappingProviders(), + NullDefaultJavaAttributeMappingProvider.instance()); + } + /** - * the "null" attribute mapping is used when the attribute is neither - * modified with a mapping annotation nor mapped by a "default" mapping + * No-op implementation of this method. + * @see #buildDefaultJavaAttributeMappingProviders() */ - protected JavaAttributeMappingProvider getNullAttributeMappingProvider() { - return JavaNullAttributeMappingProvider.instance(); + protected JavaAttributeMappingProvider[] buildNonNullDefaultJavaAttributeMappingProviders() { + return new JavaAttributeMappingProvider[0]; } - - - // ********** Mapping File ********** - public ListIterator<MappingFileProvider> mappingFileProviders() { - return new ArrayListIterator<MappingFileProvider>(getMappingFileProviders()); + public ListIterator<JavaAttributeMappingProvider> specifiedJavaAttributeMappingProviders() { + return new ArrayListIterator<JavaAttributeMappingProvider>( + getSpecifiedJavaAttributeMappingProviders()); } - protected synchronized MappingFileProvider[] getMappingFileProviders() { - if (this.mappingFileProviders == null) { - this.mappingFileProviders = this.buildMappingFileProviders(); + protected synchronized JavaAttributeMappingProvider[] getSpecifiedJavaAttributeMappingProviders() { + if (this.specifiedJavaAttributeMappingProviders == null) { + this.specifiedJavaAttributeMappingProviders = this.buildSpecifiedJavaAttributeMappingProviders(); } - return this.mappingFileProviders; + return this.specifiedJavaAttributeMappingProviders; } - - protected MappingFileProvider[] buildMappingFileProviders() { - ArrayList<MappingFileProvider> providers = new ArrayList<MappingFileProvider>(); - this.addMappingFileProvidersTo(providers); - return providers.toArray(new MappingFileProvider[providers.size()]); - } - + /** - * Implement this to specify mapping file providers. + * Return an array of mapping providers to use for analyzing the specified mapping of an attribute + * given all annotations on it. The order is important, as once a mapping provider tests + * positively for a given attribute, all following mapping providers are ignored. + * Extenders may either overwrite this method or + * {@link #buildNonNullSpecifiedJavaAttributeMappingProviders()}. + * Doing the former places the additional requirement on the extender to provide a "null" + * mapping provider (@see {@link NullSpecifiedJavaAttributeMappingProvider}.) */ - protected abstract void addMappingFileProvidersTo(List<MappingFileProvider> providers); - - - // ********** ORM type mappings ********** - - public ListIterator<OrmTypeMappingProvider> ormTypeMappingProviders() { - return new ArrayListIterator<OrmTypeMappingProvider>(getOrmTypeMappingProviders()); + protected JavaAttributeMappingProvider[] buildSpecifiedJavaAttributeMappingProviders() { + return CollectionTools.add( + buildNonNullSpecifiedJavaAttributeMappingProviders(), + NullSpecifiedJavaAttributeMappingProvider.instance()); } - protected synchronized OrmTypeMappingProvider[] getOrmTypeMappingProviders() { - if (this.ormTypeMappingProviders == null) { - this.ormTypeMappingProviders = this.buildOrmTypeMappingProviders(); - } - return this.ormTypeMappingProviders; - } - - protected OrmTypeMappingProvider[] buildOrmTypeMappingProviders() { - ArrayList<OrmTypeMappingProvider> providers = new ArrayList<OrmTypeMappingProvider>(); - this.addOrmTypeMappingProvidersTo(providers); - return providers.toArray(new OrmTypeMappingProvider[providers.size()]); - } - /** - * Implement this to specify type mapping providers. + * No-op implementation of this method. + * @see #buildSpecifiedJavaAttributeMappingProviders() */ - protected abstract void addOrmTypeMappingProvidersTo(List<OrmTypeMappingProvider> providers); - - - // ********** ORM attribute mappings ********** - - public ListIterator<OrmAttributeMappingProvider> ormAttributeMappingProviders() { - return new ArrayListIterator<OrmAttributeMappingProvider>(getOrmAttributeMappingProviders()); + protected JavaAttributeMappingProvider[] buildNonNullSpecifiedJavaAttributeMappingProviders() { + return new JavaAttributeMappingProvider[0]; } - - protected synchronized OrmAttributeMappingProvider[] getOrmAttributeMappingProviders() { - if (this.ormAttributeMappingProviders == null) { - this.ormAttributeMappingProviders = this.buildOrmAttributeMappingProviders(); - } - return this.ormAttributeMappingProviders; + + + // ********** Mapping Files ********** + + public ListIterator<MappingFileDefinition> mappingFileDefinitions() { + return new ArrayListIterator<MappingFileDefinition>(getMappingFileDefinitions()); } - - protected OrmAttributeMappingProvider[] buildOrmAttributeMappingProviders() { - ArrayList<OrmAttributeMappingProvider> providers = new ArrayList<OrmAttributeMappingProvider>(); - this.addOrmAttributeMappingProvidersTo(providers); - return providers.toArray(new OrmAttributeMappingProvider[providers.size()]); + + protected synchronized MappingFileDefinition[] getMappingFileDefinitions() { + if (this.mappingFileDefinitions == null) { + this.mappingFileDefinitions = this.buildMappingFileDefinitions(); + } + return this.mappingFileDefinitions; } - - /** - * Implement this to specify attribute mapping providers. - */ - protected abstract void addOrmAttributeMappingProvidersTo(List<OrmAttributeMappingProvider> providers); + + protected abstract MappingFileDefinition[] buildMappingFileDefinitions(); } diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/AbstractMappingFileDefinition.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/AbstractMappingFileDefinition.java new file mode 100644 index 0000000000..8355a1486c --- /dev/null +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/AbstractMappingFileDefinition.java @@ -0,0 +1,95 @@ +/******************************************************************************* + * Copyright (c) 2009 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.platform; + +import java.util.ListIterator; +import org.eclipse.jpt.core.context.MappingFileDefinition; +import org.eclipse.jpt.core.context.orm.OrmAttributeMappingProvider; +import org.eclipse.jpt.core.context.orm.OrmTypeMappingProvider; +import org.eclipse.jpt.utility.internal.CollectionTools; +import org.eclipse.jpt.utility.internal.iterators.ArrayListIterator; + +/** + * All the state in the definition should be "static" (i.e. unchanging once it is initialized). + */ +public abstract class AbstractMappingFileDefinition + implements MappingFileDefinition +{ + private OrmTypeMappingProvider[] ormTypeMappingProviders; + + private OrmAttributeMappingProvider[] ormAttributeMappingProviders; + + + /** + * zero-argument constructor + */ + protected AbstractMappingFileDefinition() { + super(); + } + + + // ********** ORM type mappings ********** + + public OrmTypeMappingProvider getOrmTypeMappingProvider(String mappingKey) { + for (OrmTypeMappingProvider provider : CollectionTools.iterable(ormTypeMappingProviders())) { + if (provider.getKey() == mappingKey) { + return provider; + } + } + throw new IllegalArgumentException("Illegal type mapping key: " + mappingKey); //$NON-NLS-1$ + } + + public ListIterator<OrmTypeMappingProvider> ormTypeMappingProviders() { + return new ArrayListIterator<OrmTypeMappingProvider>(getOrmTypeMappingProviders()); + } + + protected synchronized OrmTypeMappingProvider[] getOrmTypeMappingProviders() { + if (this.ormTypeMappingProviders == null) { + this.ormTypeMappingProviders = this.buildOrmTypeMappingProviders(); + } + return this.ormTypeMappingProviders; + } + + /** + * Return an array of mapping providers to use for types in mapping files of this type. + * The order is unimportant. + */ + protected abstract OrmTypeMappingProvider[] buildOrmTypeMappingProviders(); + + + // ********** ORM attribute mappings ********** + + public OrmAttributeMappingProvider getOrmAttributeMappingProvider(String mappingKey) { + for (OrmAttributeMappingProvider provider : CollectionTools.iterable(ormAttributeMappingProviders())) { + if (provider.getKey() == mappingKey) { + return provider; + } + } + throw new IllegalArgumentException("Illegal type mapping key: " + mappingKey); //$NON-NLS-1$ + } + + public ListIterator<OrmAttributeMappingProvider> ormAttributeMappingProviders() { + return new ArrayListIterator<OrmAttributeMappingProvider>(getOrmAttributeMappingProviders()); + } + + protected synchronized OrmAttributeMappingProvider[] getOrmAttributeMappingProviders() { + if (this.ormAttributeMappingProviders == null) { + this.ormAttributeMappingProviders = this.buildOrmAttributeMappingProviders(); + } + return this.ormAttributeMappingProviders; + } + + /** + * Return an array of mapping providers to use for attributes in mapping files of this type. + * The order is unimportant. + */ + protected abstract OrmAttributeMappingProvider[] buildOrmAttributeMappingProviders(); +} diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/GenericJpaPlatform.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/GenericJpaPlatform.java index b2864d8f4d..d79e3f3173 100644 --- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/GenericJpaPlatform.java +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/GenericJpaPlatform.java @@ -23,9 +23,7 @@ import org.eclipse.jpt.core.JpaProject; import org.eclipse.jpt.core.JpaResourceModel; import org.eclipse.jpt.core.JpaResourceModelProvider; import org.eclipse.jpt.core.JpaValidation; -import org.eclipse.jpt.core.context.MappingFile; -import org.eclipse.jpt.core.context.MappingFileProvider; -import org.eclipse.jpt.core.context.java.DefaultJavaAttributeMappingProvider; +import org.eclipse.jpt.core.context.MappingFileDefinition; import org.eclipse.jpt.core.context.java.JavaAttributeMapping; import org.eclipse.jpt.core.context.java.JavaAttributeMappingProvider; import org.eclipse.jpt.core.context.java.JavaPersistentAttribute; @@ -34,27 +32,21 @@ import org.eclipse.jpt.core.context.java.JavaTypeMapping; import org.eclipse.jpt.core.context.java.JavaTypeMappingProvider; import org.eclipse.jpt.core.context.orm.OrmAttributeMapping; import org.eclipse.jpt.core.context.orm.OrmAttributeMappingProvider; +import org.eclipse.jpt.core.context.orm.NullOrmAttributeMappingProvider; import org.eclipse.jpt.core.context.orm.OrmPersistentAttribute; import org.eclipse.jpt.core.context.orm.OrmPersistentType; import org.eclipse.jpt.core.context.orm.OrmTypeMapping; import org.eclipse.jpt.core.context.orm.OrmTypeMappingProvider; -import org.eclipse.jpt.core.context.persistence.MappingFileRef; -import org.eclipse.jpt.core.internal.context.java.JavaNullAttributeMappingProvider; -import org.eclipse.jpt.core.internal.context.orm.OrmNullAttributeMappingProvider; import org.eclipse.jpt.core.internal.utility.PlatformTools; import org.eclipse.jpt.core.internal.utility.jdt.DefaultAnnotationEditFormatter; import org.eclipse.jpt.core.resource.orm.XmlAttributeMapping; import org.eclipse.jpt.core.resource.orm.XmlTypeMapping; -import org.eclipse.jpt.core.resource.xml.JpaXmlResource; import org.eclipse.jpt.core.utility.jdt.AnnotationEditFormatter; import org.eclipse.jpt.db.ConnectionProfileFactory; import org.eclipse.jpt.db.DatabaseFinder; import org.eclipse.jpt.db.JptDbPlugin; import org.eclipse.jpt.utility.internal.CollectionTools; -import org.eclipse.jpt.utility.internal.iterators.ArrayListIterator; -import org.eclipse.jpt.utility.internal.iterators.CompositeListIterator; import org.eclipse.jpt.utility.internal.iterators.FilteringIterator; -import org.eclipse.jpt.utility.internal.iterators.TransformationListIterator; /** * All the state in the JPA platform should be "static" (i.e. unchanging once @@ -63,26 +55,27 @@ import org.eclipse.jpt.utility.internal.iterators.TransformationListIterator; public class GenericJpaPlatform implements JpaPlatform { - private final String id; - + private final JpaFactory jpaFactory; - + private final JpaAnnotationProvider annotationProvider; - - private final JpaPlatformProvider[] platformProviders; + + private final JpaPlatformProvider platformProvider; private final JpaValidation jpaValidation; - public GenericJpaPlatform(String id, JpaFactory jpaFactory, JpaAnnotationProvider jpaAnnotationProvider, JpaValidation jpaValidation, JpaPlatformProvider... platformProviders) { + + public GenericJpaPlatform(String id, JpaFactory jpaFactory, JpaAnnotationProvider jpaAnnotationProvider, JpaPlatformProvider platformProvider, JpaValidation jpaValidation) { super(); this.id = id; this.jpaFactory = jpaFactory; this.annotationProvider = jpaAnnotationProvider; this.jpaValidation = jpaValidation; - this.platformProviders = platformProviders; + this.platformProvider = platformProvider; } - + + public String getId() { return this.id; } @@ -97,10 +90,11 @@ public class GenericJpaPlatform // ********** platform providers ********** - protected ListIterator<JpaPlatformProvider> platformProviders() { - return new ArrayListIterator<JpaPlatformProvider>(this.platformProviders); + protected JpaPlatformProvider getPlatformProvider() { + return this.platformProvider; } - + + // ********** JPA file/resource models ********** public JpaFile buildJpaFile(JpaProject jpaProject, IFile file) { @@ -132,16 +126,10 @@ public class GenericJpaPlatform } protected ListIterator<JpaResourceModelProvider> resourceModelProviders() { - return new CompositeListIterator<JpaResourceModelProvider> ( - new TransformationListIterator<JpaPlatformProvider, ListIterator<JpaResourceModelProvider>>(this.platformProviders()) { - @Override - protected ListIterator<JpaResourceModelProvider> transform(JpaPlatformProvider platformProvider) { - return platformProvider.resourceModelProviders(); - } - } - ); + return this.platformProvider.resourceModelProviders(); } - + + // ********** Java annotations ********** public JpaAnnotationProvider getAnnotationProvider() { @@ -169,14 +157,7 @@ public class GenericJpaPlatform } protected ListIterator<JavaTypeMappingProvider> javaTypeMappingProviders() { - return new CompositeListIterator<JavaTypeMappingProvider> ( - new TransformationListIterator<JpaPlatformProvider, ListIterator<JavaTypeMappingProvider>>(this.platformProviders()) { - @Override - protected ListIterator<JavaTypeMappingProvider> transform(JpaPlatformProvider platformProvider) { - return platformProvider.javaTypeMappingProviders(); - } - } - ); + return this.platformProvider.javaTypeMappingProviders(); } public JavaTypeMapping buildJavaTypeMappingFromAnnotation(String annotationName, JavaPersistentType type) { @@ -194,200 +175,63 @@ public class GenericJpaPlatform // ********** Java attribute mappings ********** - - public JavaAttributeMapping buildJavaAttributeMappingFromMappingKey(String key, JavaPersistentAttribute attribute) { - return this.getJavaAttributeMappingProviderForMappingKey(key).buildMapping(attribute, this.jpaFactory); - } - - protected JavaAttributeMappingProvider getJavaAttributeMappingProviderForMappingKey(String key) { - for (JavaAttributeMappingProvider provider : CollectionTools.iterable(javaAttributeMappingProviders())) { - if (provider.getKey() == key) { - return provider; - } - } - throw new IllegalArgumentException("Illegal attribute mapping key: " + key); //$NON-NLS-1$ - } - - protected ListIterator<JavaAttributeMappingProvider> javaAttributeMappingProviders() { - return new CompositeListIterator<JavaAttributeMappingProvider> ( - new TransformationListIterator<JpaPlatformProvider, ListIterator<JavaAttributeMappingProvider>>(this.platformProviders()) { - @Override - protected ListIterator<JavaAttributeMappingProvider> transform(JpaPlatformProvider platformProvider) { - return platformProvider.javaAttributeMappingProviders(); - } - } - ); - } - - public JavaAttributeMapping buildJavaAttributeMappingFromAnnotation(String annotationName, JavaPersistentAttribute attribute) { - return this.getJavaAttributeMappingProviderForAnnotation(annotationName).buildMapping(attribute, this.jpaFactory); - } - - protected JavaAttributeMappingProvider getJavaAttributeMappingProviderForAnnotation(String annotationName) { - for (JavaAttributeMappingProvider provider : CollectionTools.iterable(javaAttributeMappingProviders())) { - if (provider.getAnnotationName() == annotationName) { - return provider; - } - } - throw new IllegalArgumentException("Illegal annotation name: " + annotationName); //$NON-NLS-1$ - } - - // ********** default Java attribute mappings ********** - - public JavaAttributeMapping buildDefaultJavaAttributeMapping(JavaPersistentAttribute attribute) { - return this.getDefaultJavaAttributeMappingProvider(attribute).buildMapping(attribute, this.jpaFactory); - } - - public String getDefaultJavaAttributeMappingKey(JavaPersistentAttribute attribute) { - return this.getDefaultJavaAttributeMappingProvider(attribute).getKey(); - } - protected ListIterator<DefaultJavaAttributeMappingProvider> defaultJavaAttributeMappingProviders() { - return new CompositeListIterator<DefaultJavaAttributeMappingProvider> ( - new TransformationListIterator<JpaPlatformProvider, ListIterator<DefaultJavaAttributeMappingProvider>>(this.platformProviders()) { - @Override - protected ListIterator<DefaultJavaAttributeMappingProvider> transform(JpaPlatformProvider platformProvider) { - return platformProvider.defaultJavaAttributeMappingProviders(); - } - } - ); - } - - protected JavaAttributeMappingProvider getDefaultJavaAttributeMappingProvider(JavaPersistentAttribute attribute) { - for (DefaultJavaAttributeMappingProvider provider : CollectionTools.iterable(this.defaultJavaAttributeMappingProviders())) { + public JavaAttributeMappingProvider getDefaultJavaAttributeMappingProvider( + JavaPersistentAttribute attribute) { + for (JavaAttributeMappingProvider provider : + CollectionTools.iterable(defaultJavaAttributeMappingProviders())) { if (provider.defaultApplies(attribute)) { return provider; } } - return this.getNullAttributeMappingProvider(); - } - - /** - * the "null" attribute mapping is used when the attribute is neither - * modified with a mapping annotation nor mapped by a "default" mapping - */ - protected JavaAttributeMappingProvider getNullAttributeMappingProvider() { - return JavaNullAttributeMappingProvider.instance(); + throw new IllegalStateException("There must be a mapping provider for all attributes"); //$NON-NLS-1$ } - - - // ********** Mapping File ********** - - public MappingFile buildMappingFile(MappingFileRef parent, JpaXmlResource resource) { - return this.getMappingFileProviderForResourceType(resource.getContentType()).buildMappingFile(parent, resource, this.jpaFactory); + + protected ListIterator<JavaAttributeMappingProvider> defaultJavaAttributeMappingProviders() { + return this.platformProvider.defaultJavaAttributeMappingProviders(); } - - protected MappingFileProvider getMappingFileProviderForResourceType(IContentType contentType) { - for (MappingFileProvider provider : CollectionTools.iterable(this.mappingFileProviders())) { - if (provider.getContentType().equals(contentType)) { + + public JavaAttributeMappingProvider getSpecifiedJavaAttributeMappingProvider( + JavaPersistentAttribute attribute) { + for (JavaAttributeMappingProvider provider : + CollectionTools.iterable(specifiedJavaAttributeMappingProviders())) { + if (provider.specifiedApplies(attribute)) { return provider; } } - throw new IllegalArgumentException("Illegal mapping file content type: " + contentType); //$NON-NLS-1$ + throw new IllegalStateException("There must be a mapping provider for all attributes"); //$NON-NLS-1$ } - protected ListIterator<MappingFileProvider> mappingFileProviders() { - return new CompositeListIterator<MappingFileProvider> ( - new TransformationListIterator<JpaPlatformProvider, ListIterator<MappingFileProvider>>(this.platformProviders()) { - @Override - protected ListIterator<MappingFileProvider> transform(JpaPlatformProvider platformProvider) { - return platformProvider.mappingFileProviders(); - } - } - ); - } - - - // ********** ORM type mappings ********** - - public XmlTypeMapping buildOrmResourceTypeMapping(String key, IContentType contentType) { - return this.getOrmTypeMappingProviderForMappingKey(contentType, key).buildResourceMapping(); + protected ListIterator<JavaAttributeMappingProvider> specifiedJavaAttributeMappingProviders() { + return this.platformProvider.specifiedJavaAttributeMappingProviders(); } - public OrmTypeMapping buildOrmTypeMappingFromMappingKey(OrmPersistentType type, XmlTypeMapping resourceMapping) { - return this.getOrmTypeMappingProviderForMappingKey(type.getContentType(), resourceMapping.getMappingKey()).buildMapping(type, resourceMapping, this.jpaFactory); - } - - protected OrmTypeMappingProvider getOrmTypeMappingProviderForMappingKey(IContentType contentType, String key) { - for (OrmTypeMappingProvider provider : CollectionTools.iterable(this.ormTypeMappingProviders(key))) { - if (provider.getContentType().isKindOf(contentType)) { + public JavaAttributeMappingProvider getSpecifiedJavaAttributeMappingProvider(String mappingKey) { + for (JavaAttributeMappingProvider provider : CollectionTools.iterable(specifiedJavaAttributeMappingProviders())) { + if (provider.getKey() == mappingKey) { return provider; } } - if (contentType.getBaseType() != null) { - return getOrmTypeMappingProviderForMappingKey(contentType.getBaseType(), key); - } - throw new IllegalArgumentException("Illegal type mapping key: " + key); //$NON-NLS-1$ - } - - protected Iterator<OrmTypeMappingProvider> ormTypeMappingProviders(final String key) { - return new FilteringIterator<OrmTypeMappingProvider, OrmTypeMappingProvider>(ormTypeMappingProviders()) { - @Override - protected boolean accept(OrmTypeMappingProvider o) { - return o.getKey() == key; - } - }; - } - - protected ListIterator<OrmTypeMappingProvider> ormTypeMappingProviders() { - return new CompositeListIterator<OrmTypeMappingProvider> ( - new TransformationListIterator<JpaPlatformProvider, ListIterator<OrmTypeMappingProvider>>(this.platformProviders()) { - @Override - protected ListIterator<OrmTypeMappingProvider> transform(JpaPlatformProvider platformProvider) { - return platformProvider.ormTypeMappingProviders(); - } - } - ); + throw new IllegalArgumentException("Illegal attribute mapping key: " + mappingKey); //$NON-NLS-1$ } - // ********** ORM attribute mappings ********** + // ********** Mapping Files ********** - public XmlAttributeMapping buildOrmResourceAttributeMapping(String key, IContentType contentType) { - return this.getOrmAttributeMappingProviderForMappingKey(contentType, key).buildResourceMapping(); - } - - public OrmAttributeMapping buildOrmAttributeMappingFromMappingKey(OrmPersistentAttribute attribute, XmlAttributeMapping resourceMapping) { - return this.getOrmAttributeMappingProviderForMappingKey(attribute.getContentType(), resourceMapping.getMappingKey()).buildMapping(attribute, resourceMapping, this.jpaFactory); - } - - public XmlAttributeMapping buildVirtualOrmResourceMappingFromMappingKey(String key, OrmTypeMapping ormTypeMapping, JavaAttributeMapping javaAttributeMapping) { - return this.getOrmAttributeMappingProviderForMappingKey(ormTypeMapping.getContentType(), key).buildVirtualResourceMapping(ormTypeMapping, javaAttributeMapping, this.jpaFactory); - } - - protected OrmAttributeMappingProvider getOrmAttributeMappingProviderForMappingKey(IContentType contentType, String key) { - for (OrmAttributeMappingProvider provider : CollectionTools.iterable(this.ormAttributeMappingProviders(key))) { - if (provider.getContentType().isKindOf(contentType)) { - return provider; + public MappingFileDefinition getMappingFileDefinition(IContentType contentType) { + for (MappingFileDefinition mappingFileDef : CollectionTools.iterable(mappingFileDefinitions())) { + if (mappingFileDef.getContentType().isKindOf(contentType)) { + return mappingFileDef; } } - if (contentType.getBaseType() != null) { - return getOrmAttributeMappingProviderForMappingKey(contentType.getBaseType(), key); - } - return OrmNullAttributeMappingProvider.instance(); + throw new IllegalArgumentException("Illegal mapping file content type: " + contentType); //$NON-NLS-1$ } - protected Iterator<OrmAttributeMappingProvider> ormAttributeMappingProviders(final String key) { - return new FilteringIterator<OrmAttributeMappingProvider, OrmAttributeMappingProvider>(ormAttributeMappingProviders()) { - @Override - protected boolean accept(OrmAttributeMappingProvider o) { - return o.getKey() == key; - } - }; + protected ListIterator<MappingFileDefinition> mappingFileDefinitions() { + return this.platformProvider.mappingFileDefinitions(); } - - protected ListIterator<OrmAttributeMappingProvider> ormAttributeMappingProviders() { - return new CompositeListIterator<OrmAttributeMappingProvider> ( - new TransformationListIterator<JpaPlatformProvider, ListIterator<OrmAttributeMappingProvider>>(this.platformProviders()) { - @Override - protected ListIterator<OrmAttributeMappingProvider> transform(JpaPlatformProvider platformProvider) { - return platformProvider.ormAttributeMappingProviders(); - } - } - ); - } - - + + // ********** database ********** public ConnectionProfileFactory getConnectionProfileFactory() { diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/GenericJpaPlatformFactory.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/GenericJpaPlatformFactory.java index ae3fbd0cf9..30c8085a34 100644 --- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/GenericJpaPlatformFactory.java +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/GenericJpaPlatformFactory.java @@ -9,12 +9,8 @@ ******************************************************************************/ package org.eclipse.jpt.core.internal.platform; -import org.eclipse.jpt.core.JpaAnnotationDefinitionProvider; -import org.eclipse.jpt.core.JpaAnnotationProvider; -import org.eclipse.jpt.core.JpaFactory; import org.eclipse.jpt.core.JpaPlatform; import org.eclipse.jpt.core.JpaPlatformFactory; -import org.eclipse.jpt.core.JpaPlatformProvider; import org.eclipse.jpt.core.JpaValidation; /** @@ -24,7 +20,6 @@ import org.eclipse.jpt.core.JpaValidation; public class GenericJpaPlatformFactory implements JpaPlatformFactory { - /** * zero-argument constructor */ @@ -35,30 +30,12 @@ public class GenericJpaPlatformFactory public JpaPlatform buildJpaPlatform(String id) { return new GenericJpaPlatform( id, - this.buildJpaFactory(), - this.buildJpaAnnotationProvider(), - this.buildJpaValidation(), - this.platformProviders()); - } - - protected JpaFactory buildJpaFactory() { - return new GenericJpaFactory(); + new GenericJpaFactory(), + new GenericJpaAnnotationProvider(GenericJpaAnnotationDefinitionProvider.instance()), + GenericJpaPlatformProvider.instance(), + this.buildJpaValidation()); } - protected JpaAnnotationProvider buildJpaAnnotationProvider() { - return new GenericJpaAnnotationProvider(this.annotationDefinitionProvider()); - } - - protected JpaPlatformProvider[] platformProviders() { - JpaPlatformProvider[] platformProviders = { - GenericJpaPlatformProvider.instance() - }; - return platformProviders; - } - - protected JpaAnnotationDefinitionProvider annotationDefinitionProvider() { - return GenericJpaAnnotationDefinitionProvider.instance(); - } protected JpaValidation buildJpaValidation() { return new JpaValidation() { diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/GenericJpaPlatformProvider.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/GenericJpaPlatformProvider.java index 92692ae51b..98d43f7a25 100644 --- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/GenericJpaPlatformProvider.java +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/platform/GenericJpaPlatformProvider.java @@ -9,21 +9,15 @@ ******************************************************************************/ package org.eclipse.jpt.core.internal.platform; -import java.util.List; - import org.eclipse.jpt.core.JpaPlatformProvider; import org.eclipse.jpt.core.JpaResourceModelProvider; -import org.eclipse.jpt.core.context.MappingFileProvider; -import org.eclipse.jpt.core.context.java.DefaultJavaAttributeMappingProvider; +import org.eclipse.jpt.core.context.MappingFileDefinition; import org.eclipse.jpt.core.context.java.JavaAttributeMappingProvider; import org.eclipse.jpt.core.context.java.JavaTypeMappingProvider; -import org.eclipse.jpt.core.context.orm.OrmAttributeMappingProvider; -import org.eclipse.jpt.core.context.orm.OrmTypeMappingProvider; import org.eclipse.jpt.core.internal.JarResourceModelProvider; import org.eclipse.jpt.core.internal.JavaResourceModelProvider; import org.eclipse.jpt.core.internal.OrmResourceModelProvider; import org.eclipse.jpt.core.internal.PersistenceResourceModelProvider; -import org.eclipse.jpt.core.internal.context.GenericMappingFileProvider; import org.eclipse.jpt.core.internal.context.java.JavaBasicMappingProvider; import org.eclipse.jpt.core.internal.context.java.JavaEmbeddableProvider; import org.eclipse.jpt.core.internal.context.java.JavaEmbeddedIdMappingProvider; @@ -33,132 +27,99 @@ import org.eclipse.jpt.core.internal.context.java.JavaIdMappingProvider; import org.eclipse.jpt.core.internal.context.java.JavaManyToManyMappingProvider; import org.eclipse.jpt.core.internal.context.java.JavaManyToOneMappingProvider; import org.eclipse.jpt.core.internal.context.java.JavaMappedSuperclassProvider; -import org.eclipse.jpt.core.internal.context.java.JavaNullTypeMappingProvider; import org.eclipse.jpt.core.internal.context.java.JavaOneToManyMappingProvider; import org.eclipse.jpt.core.internal.context.java.JavaOneToOneMappingProvider; import org.eclipse.jpt.core.internal.context.java.JavaTransientMappingProvider; import org.eclipse.jpt.core.internal.context.java.JavaVersionMappingProvider; -import org.eclipse.jpt.core.internal.context.orm.OrmBasicMappingProvider; -import org.eclipse.jpt.core.internal.context.orm.OrmEmbeddableProvider; -import org.eclipse.jpt.core.internal.context.orm.OrmEmbeddedIdMappingProvider; -import org.eclipse.jpt.core.internal.context.orm.OrmEmbeddedMappingProvider; -import org.eclipse.jpt.core.internal.context.orm.OrmEntityProvider; -import org.eclipse.jpt.core.internal.context.orm.OrmIdMappingProvider; -import org.eclipse.jpt.core.internal.context.orm.OrmManyToManyMappingProvider; -import org.eclipse.jpt.core.internal.context.orm.OrmManyToOneMappingProvider; -import org.eclipse.jpt.core.internal.context.orm.OrmMappedSuperclassProvider; -import org.eclipse.jpt.core.internal.context.orm.OrmOneToManyMappingProvider; -import org.eclipse.jpt.core.internal.context.orm.OrmOneToOneMappingProvider; -import org.eclipse.jpt.core.internal.context.orm.OrmTransientMappingProvider; -import org.eclipse.jpt.core.internal.context.orm.OrmVersionMappingProvider; +import org.eclipse.jpt.core.internal.context.orm.GenericOrmMappingFileDefinition; /** * All the state in the JPA platform should be "static" (i.e. unchanging once * it is initialized). */ -public class GenericJpaPlatformProvider extends AbstractJpaPlatformProvider +public class GenericJpaPlatformProvider + extends AbstractJpaPlatformProvider { public static final String ID = "generic"; //$NON-NLS-1$ - + // singleton - private static final JpaPlatformProvider INSTANCE = new GenericJpaPlatformProvider(); - + private static final JpaPlatformProvider INSTANCE = + new GenericJpaPlatformProvider(); + + /** * Return the singleton. */ public static JpaPlatformProvider instance() { return INSTANCE; } - + + /** - * Ensure single instance. + * Enforce singleton usage */ private GenericJpaPlatformProvider() { super(); } - - + + // ********** resource models ********** - + @Override - protected void addResourceModelProvidersTo(List<JpaResourceModelProvider> providers) { - providers.add(JavaResourceModelProvider.instance()); - providers.add(PersistenceResourceModelProvider.instance()); - providers.add(OrmResourceModelProvider.instance()); - providers.add(JarResourceModelProvider.instance()); + protected JpaResourceModelProvider[] buildResourceModelProviders() { + // order should not be important here + return new JpaResourceModelProvider[] { + JavaResourceModelProvider.instance(), + JarResourceModelProvider.instance(), + PersistenceResourceModelProvider.instance(), + OrmResourceModelProvider.instance()}; } - - + + // ********** Java type mappings ********** @Override - protected void addJavaTypeMappingProvidersTo(List<JavaTypeMappingProvider> providers) { - providers.add(JavaEntityProvider.instance()); - providers.add(JavaMappedSuperclassProvider.instance()); - providers.add(JavaEmbeddableProvider.instance()); - providers.add(JavaNullTypeMappingProvider.instance()); + protected JavaTypeMappingProvider[] buildNonNullJavaTypeMappingProviders() { + // order determined by analyzing order that reference implementation (toplink) uses + return new JavaTypeMappingProvider[] { + JavaEntityProvider.instance(), + JavaEmbeddableProvider.instance(), + JavaMappedSuperclassProvider.instance()}; } - - + + // ********** Java attribute mappings ********** - - @Override - protected void addJavaAttributeMappingProvidersTo(List<JavaAttributeMappingProvider> providers) { - providers.add(JavaBasicMappingProvider.instance()); - providers.add(JavaEmbeddedMappingProvider.instance()); - providers.add(JavaEmbeddedIdMappingProvider.instance()); - providers.add(JavaIdMappingProvider.instance()); - providers.add(JavaManyToManyMappingProvider.instance()); - providers.add(JavaManyToOneMappingProvider.instance()); - providers.add(JavaOneToManyMappingProvider.instance()); - providers.add(JavaOneToOneMappingProvider.instance()); - providers.add(JavaTransientMappingProvider.instance()); - providers.add(JavaVersionMappingProvider.instance()); - } - - - // ********** default Java attribute mappings ********** - - @Override - protected void addDefaultJavaAttributeMappingProvidersTo(List<DefaultJavaAttributeMappingProvider> providers) { - providers.add(JavaEmbeddedMappingProvider.instance()); // bug 190344 need to test default embedded before basic - providers.add(JavaBasicMappingProvider.instance()); - } - - // ********** Mapping File ********** - - /** - * Override this to specify more or different mapping file providers. - */ + @Override - protected void addMappingFileProvidersTo(List<MappingFileProvider> providers) { - providers.add(GenericMappingFileProvider.instance()); + protected JavaAttributeMappingProvider[] buildNonNullDefaultJavaAttributeMappingProviders() { + // order determined by analyzing order that reference implementation (toplink) uses + return new JavaAttributeMappingProvider[] { + JavaEmbeddedMappingProvider.instance(), + JavaBasicMappingProvider.instance()}; } - - - // ********** ORM type mappings ********** - + @Override - protected void addOrmTypeMappingProvidersTo(List<OrmTypeMappingProvider> providers) { - providers.add(OrmEmbeddableProvider.instance()); - providers.add(OrmEntityProvider.instance()); - providers.add(OrmMappedSuperclassProvider.instance()); + protected JavaAttributeMappingProvider[] buildNonNullSpecifiedJavaAttributeMappingProviders() { + // order determined by analyzing order that reference implementation (toplink) uses + return new JavaAttributeMappingProvider[] { + JavaTransientMappingProvider.instance(), + JavaIdMappingProvider.instance(), + JavaVersionMappingProvider.instance(), + JavaBasicMappingProvider.instance(), + JavaEmbeddedMappingProvider.instance(), + JavaEmbeddedIdMappingProvider.instance(), + JavaManyToManyMappingProvider.instance(), + JavaManyToOneMappingProvider.instance(), + JavaOneToManyMappingProvider.instance(), + JavaOneToOneMappingProvider.instance()}; } - - - // ********** ORM attribute mappings ********** - + + + // ********** Mapping Files ********** + @Override - protected void addOrmAttributeMappingProvidersTo(List<OrmAttributeMappingProvider> providers) { - providers.add(OrmEmbeddedMappingProvider.instance()); // bug 190344 need to test default embedded before basic - providers.add(OrmBasicMappingProvider.instance()); - providers.add(OrmTransientMappingProvider.instance()); - providers.add(OrmIdMappingProvider.instance()); - providers.add(OrmManyToManyMappingProvider.instance()); - providers.add(OrmOneToManyMappingProvider.instance()); - providers.add(OrmManyToOneMappingProvider.instance()); - providers.add(OrmOneToOneMappingProvider.instance()); - providers.add(OrmVersionMappingProvider.instance()); - providers.add(OrmEmbeddedIdMappingProvider.instance()); + protected MappingFileDefinition[] buildMappingFileDefinitions() { + return new MappingFileDefinition[] { + GenericOrmMappingFileDefinition.instance()}; } } diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/resource/orm/XmlAttributeMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/resource/orm/XmlAttributeMapping.java index 568a076b72..7b70049969 100644 --- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/resource/orm/XmlAttributeMapping.java +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/resource/orm/XmlAttributeMapping.java @@ -21,7 +21,9 @@ import org.eclipse.jpt.core.resource.orm.XmlAccessHolder; * @model kind="class" interface="true" abstract="true" * @generated */ -public interface XmlAttributeMapping extends org.eclipse.jpt.core.resource.orm.XmlAttributeMapping, XmlAccessHolder +public interface XmlAttributeMapping + extends org.eclipse.jpt.core.resource.orm.XmlAttributeMapping, + XmlAccessHolder { } // XmlAttributeMapping diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/AbstractXmlAttributeMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/AbstractXmlAttributeMapping.java index c9d7cdb844..51fae884da 100644 --- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/AbstractXmlAttributeMapping.java +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/AbstractXmlAttributeMapping.java @@ -32,7 +32,9 @@ import org.eclipse.wst.common.internal.emf.resource.Translator; * @model kind="class" abstract="true" * @generated */ -public abstract class AbstractXmlAttributeMapping extends AbstractJpaEObject implements XmlAttributeMapping +public abstract class AbstractXmlAttributeMapping + extends AbstractJpaEObject + implements XmlAttributeMapping { /** * The default value of the '{@link #getName() <em>Name</em>}' attribute. diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/OrmPackage.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/OrmPackage.java index bf4d6479df..3a9589f165 100644 --- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/OrmPackage.java +++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/resource/orm/OrmPackage.java @@ -5130,20 +5130,14 @@ public class OrmPackage extends EPackageImpl XMLTypePackage.eINSTANCE.eClass(); // Obtain or create and register interdependencies - Orm2_0Package theOrm2_0Package = (Orm2_0Package)(EPackage.Registry.INSTANCE.getEPackage(Orm2_0Package.eNS_URI) instanceof Orm2_0Package ? EPackage.Registry.INSTANCE.getEPackage(Orm2_0Package.eNS_URI) : Orm2_0Package.eINSTANCE); - Persistence2_0Package thePersistence2_0Package = (Persistence2_0Package)(EPackage.Registry.INSTANCE.getEPackage(Persistence2_0Package.eNS_URI) instanceof Persistence2_0Package ? EPackage.Registry.INSTANCE.getEPackage(Persistence2_0Package.eNS_URI) : Persistence2_0Package.eINSTANCE); PersistencePackage thePersistencePackage = (PersistencePackage)(EPackage.Registry.INSTANCE.getEPackage(PersistencePackage.eNS_URI) instanceof PersistencePackage ? EPackage.Registry.INSTANCE.getEPackage(PersistencePackage.eNS_URI) : PersistencePackage.eINSTANCE); // Create package meta-data objects theOrmPackage.createPackageContents(); - theOrm2_0Package.createPackageContents(); - thePersistence2_0Package.createPackageContents(); thePersistencePackage.createPackageContents(); // Initialize created meta-data theOrmPackage.initializePackageContents(); - theOrm2_0Package.initializePackageContents(); - thePersistence2_0Package.initializePackageContents(); thePersistencePackage.initializePackageContents(); // Mark meta-data to indicate it can't be changed |