Author: dgeraskov Date: 2009-02-10 10:12:00 -0500 (Tue, 10 Feb 2009) New Revision: 13561 Added: trunk/hibernatetools/plugins/org.jboss.tools.hibernate.jpt.core/src/org/jboss/tools/hibernate/jpt/core/internal/HibernateJptPlugin.java Modified: trunk/hibernatetools/plugins/org.jboss.tools.hibernate.jpt.core/META-INF/MANIFEST.MF trunk/hibernatetools/plugins/org.jboss.tools.hibernate.jpt.core/src/org/jboss/tools/hibernate/jpt/core/internal/HibernateJpaAnnotationProvider.java trunk/hibernatetools/plugins/org.jboss.tools.hibernate.jpt.core/src/org/jboss/tools/hibernate/jpt/core/internal/JPAPostInstallFasetListener.java trunk/hibernatetools/plugins/org.jboss.tools.hibernate.jpt.core/src/org/jboss/tools/hibernate/jpt/core/internal/context/HibernatePersistenceUnit.java trunk/hibernatetools/plugins/org.jboss.tools.hibernate.jpt.core/src/org/jboss/tools/hibernate/jpt/core/internal/context/java/GenericGeneratorAnnotationImpl.java trunk/hibernatetools/plugins/org.jboss.tools.hibernate.jpt.core/src/org/jboss/tools/hibernate/jpt/core/internal/context/java/JavaGenericGeneratorImpl.java Log: https://jira.jboss.org/jira/browse/JBIDE-3636 Dali 2.0 and 2.1 at once support. Modified: trunk/hibernatetools/plugins/org.jboss.tools.hibernate.jpt.core/META-INF/MANIFEST.MF =================================================================== --- trunk/hibernatetools/plugins/org.jboss.tools.hibernate.jpt.core/META-INF/MANIFEST.MF 2009-02-10 15:11:45 UTC (rev 13560) +++ trunk/hibernatetools/plugins/org.jboss.tools.hibernate.jpt.core/META-INF/MANIFEST.MF 2009-02-10 15:12:00 UTC (rev 13561) @@ -5,21 +5,23 @@ Bundle-Version: 1.0.0 Require-Bundle: org.eclipse.core.runtime, - org.eclipse.jpt.core, org.eclipse.wst.validation, - org.eclipse.jpt.utility;bundle-version="1.2.0", org.hibernate.eclipse.console;bundle-version="3.2.0", org.hibernate.eclipse;bundle-version="3.2.0", org.eclipse.jdt.launching;bundle-version="3.4.0", org.eclipse.debug.core;bundle-version="3.4.0", org.eclipse.emf.ecore;bundle-version="2.4.0", org.eclipse.jdt.core;bundle-version="3.4.0", - org.eclipse.wst.common.project.facet.core;bundle-version="1.3.0" + org.eclipse.wst.common.project.facet.core, + org.eclipse.jpt.core, + org.eclipse.jpt.utility, + org.eclipse.jpt.db Bundle-RequiredExecutionEnvironment: J2SE-1.5 Bundle-Vendor: %Bundle-Vendor.0 Export-Package: org.jboss.tools.hibernate.jpt.core.internal, org.jboss.tools.hibernate.jpt.core.internal.context, org.jboss.tools.hibernate.jpt.core.internal.context.basic Bundle-Localization: plugin +Bundle-Activator: org.jboss.tools.hibernate.jpt.core.internal.HibernateJptPlugin Modified: trunk/hibernatetools/plugins/org.jboss.tools.hibernate.jpt.core/src/org/jboss/tools/hibernate/jpt/core/internal/HibernateJpaAnnotationProvider.java =================================================================== --- trunk/hibernatetools/plugins/org.jboss.tools.hibernate.jpt.core/src/org/jboss/tools/hibernate/jpt/core/internal/HibernateJpaAnnotationProvider.java 2009-02-10 15:11:45 UTC (rev 13560) +++ trunk/hibernatetools/plugins/org.jboss.tools.hibernate.jpt.core/src/org/jboss/tools/hibernate/jpt/core/internal/HibernateJpaAnnotationProvider.java 2009-02-10 15:12:00 UTC (rev 13561) @@ -14,6 +14,35 @@ import java.util.List; import org.eclipse.jpt.core.internal.platform.GenericJpaAnnotationProvider; +import org.eclipse.jpt.core.internal.resource.java.AssociationOverrideImpl.AssociationOverrideAnnotationDefinition; +import org.eclipse.jpt.core.internal.resource.java.AssociationOverridesImpl.AssociationOverridesAnnotationDefinition; +import org.eclipse.jpt.core.internal.resource.java.AttributeOverrideImpl.AttributeOverrideAnnotationDefinition; +import org.eclipse.jpt.core.internal.resource.java.AttributeOverridesImpl.AttributeOverridesAnnotationDefinition; +import org.eclipse.jpt.core.internal.resource.java.ColumnImpl.ColumnAnnotationDefinition; +import org.eclipse.jpt.core.internal.resource.java.DiscriminatorColumnImpl.DiscriminatorColumnAnnotationDefinition; +import org.eclipse.jpt.core.internal.resource.java.DiscriminatorValueImpl.DiscriminatorValueAnnotationDefinition; +import org.eclipse.jpt.core.internal.resource.java.EnumeratedImpl.EnumeratedAnnotationDefinition; +import org.eclipse.jpt.core.internal.resource.java.GeneratedValueImpl.GeneratedValueAnnotationDefinition; +import org.eclipse.jpt.core.internal.resource.java.IdClassImpl.IdClassAnnotationDefinition; +import org.eclipse.jpt.core.internal.resource.java.InheritanceImpl.InheritanceAnnotationDefinition; +import org.eclipse.jpt.core.internal.resource.java.JoinColumnImpl.JoinColumnAnnotationDefinition; +import org.eclipse.jpt.core.internal.resource.java.JoinColumnsImpl.JoinColumnsAnnotationDefinition; +import org.eclipse.jpt.core.internal.resource.java.JoinTableImpl.JoinTableAnnotationDefinition; +import org.eclipse.jpt.core.internal.resource.java.LobImpl.LobAnnotationDefinition; +import org.eclipse.jpt.core.internal.resource.java.MapKeyImpl.MapKeyAnnotationDefinition; +import org.eclipse.jpt.core.internal.resource.java.NamedNativeQueriesImpl.NamedNativeQueriesAnnotationDefinition; +import org.eclipse.jpt.core.internal.resource.java.NamedNativeQueryImpl.NamedNativeQueryAnnotationDefinition; +import org.eclipse.jpt.core.internal.resource.java.NamedQueriesImpl.NamedQueriesAnnotationDefinition; +import org.eclipse.jpt.core.internal.resource.java.NamedQueryImpl.NamedQueryAnnotationDefinition; +import org.eclipse.jpt.core.internal.resource.java.OrderByImpl.OrderByAnnotationDefinition; +import org.eclipse.jpt.core.internal.resource.java.PrimaryKeyJoinColumnImpl.PrimaryKeyJoinColumnAnnotationDefinition; +import org.eclipse.jpt.core.internal.resource.java.PrimaryKeyJoinColumnsImpl.PrimaryKeyJoinColumnsAnnotationDefinition; +import org.eclipse.jpt.core.internal.resource.java.SecondaryTableImpl.SecondaryTableAnnotationDefinition; +import org.eclipse.jpt.core.internal.resource.java.SecondaryTablesImpl.SecondaryTablesAnnotationDefinition; +import org.eclipse.jpt.core.internal.resource.java.SequenceGeneratorImpl.SequenceGeneratorAnnotationDefinition; +import org.eclipse.jpt.core.internal.resource.java.TableGeneratorImpl.TableGeneratorAnnotationDefinition; +import org.eclipse.jpt.core.internal.resource.java.TableImpl.TableAnnotationDefinition; +import org.eclipse.jpt.core.internal.resource.java.TemporalImpl.TemporalAnnotationDefinition; import org.eclipse.jpt.core.resource.java.AnnotationDefinition; import org.jboss.tools.hibernate.jpt.core.internal.context.java.GenericGeneratorAnnotationImpl.GenericGeneratorAnnotationDefinition; @@ -23,22 +52,72 @@ */ public class HibernateJpaAnnotationProvider extends GenericJpaAnnotationProvider { - @Override - protected void addTypeAnnotationDefinitionsTo(Collection<AnnotationDefinition> definitions) { - super.addTypeAnnotationDefinitionsTo(definitions); - definitions.add(GenericGeneratorAnnotationDefinition.instance()); + /** + * Method for Dali 2.1 instead of {@link #addTypeAnnotationDefinitionsTo(Collection)} + */ + protected void addTypeSupportingAnnotationDefinitionsTo(List<AnnotationDefinition> definitions){ + addTypeAnnotationDefinitionsTo(definitions); } - @Override - protected void addAttributeMappingAnnotationDefinitionsTo(List<AnnotationDefinition> definitions) { - super.addAttributeMappingAnnotationDefinitionsTo(definitions); + /** + * Method for Dali 2.0 + */ + protected void addTypeAnnotationDefinitionsTo(Collection<AnnotationDefinition> definitions) { definitions.add(GenericGeneratorAnnotationDefinition.instance()); - } + //add Dali's annotation definitions + definitions.add(AssociationOverrideAnnotationDefinition.instance()); + definitions.add(AssociationOverridesAnnotationDefinition.instance()); + definitions.add(AttributeOverrideAnnotationDefinition.instance()); + definitions.add(AttributeOverrideAnnotationDefinition.instance()); + definitions.add(AttributeOverridesAnnotationDefinition.instance()); + definitions.add(DiscriminatorColumnAnnotationDefinition.instance()); + definitions.add(DiscriminatorValueAnnotationDefinition.instance()); + definitions.add(IdClassAnnotationDefinition.instance()); + definitions.add(InheritanceAnnotationDefinition.instance()); + definitions.add(NamedQueryAnnotationDefinition.instance()); + definitions.add(NamedQueriesAnnotationDefinition.instance()); + definitions.add(NamedNativeQueryAnnotationDefinition.instance()); + definitions.add(NamedNativeQueriesAnnotationDefinition.instance()); + definitions.add(PrimaryKeyJoinColumnAnnotationDefinition.instance()); + definitions.add(PrimaryKeyJoinColumnsAnnotationDefinition.instance()); + definitions.add(SecondaryTableAnnotationDefinition.instance()); + definitions.add(SecondaryTablesAnnotationDefinition.instance()); + definitions.add(SequenceGeneratorAnnotationDefinition.instance()); + definitions.add(TableAnnotationDefinition.instance()); + definitions.add(TableGeneratorAnnotationDefinition.instance()); + } - @Override + /** + * Method for Dali 2.1 instead of {@link #addAttributeAnnotationDefinitionsTo(Collection)} + */ + protected void addAttributeSupportingAnnotationDefinitionsTo(List<AnnotationDefinition> definitions) { + addAttributeAnnotationDefinitionsTo(definitions); + } + + /** + * Method for Dali 2.0 + */ protected void addAttributeAnnotationDefinitionsTo(Collection<AnnotationDefinition> definitions) { - super.addAttributeAnnotationDefinitionsTo(definitions); definitions.add(GenericGeneratorAnnotationDefinition.instance()); + //add Dali's annotation definitions + definitions.add(AssociationOverrideAnnotationDefinition.instance()); + definitions.add(AssociationOverridesAnnotationDefinition.instance()); + definitions.add(AttributeOverrideAnnotationDefinition.instance()); + definitions.add(AttributeOverridesAnnotationDefinition.instance()); + definitions.add(ColumnAnnotationDefinition.instance()); + definitions.add(EnumeratedAnnotationDefinition.instance()); + definitions.add(GeneratedValueAnnotationDefinition.instance()); + definitions.add(JoinColumnAnnotationDefinition.instance()); + definitions.add(JoinColumnsAnnotationDefinition.instance()); + definitions.add(JoinTableAnnotationDefinition.instance()); + definitions.add(LobAnnotationDefinition.instance()); + definitions.add(MapKeyAnnotationDefinition.instance()); + definitions.add(OrderByAnnotationDefinition.instance()); + definitions.add(PrimaryKeyJoinColumnAnnotationDefinition.instance()); + definitions.add(PrimaryKeyJoinColumnsAnnotationDefinition.instance()); + definitions.add(SequenceGeneratorAnnotationDefinition.instance()); + definitions.add(TableGeneratorAnnotationDefinition.instance()); + definitions.add(TemporalAnnotationDefinition.instance()); } } Added: trunk/hibernatetools/plugins/org.jboss.tools.hibernate.jpt.core/src/org/jboss/tools/hibernate/jpt/core/internal/HibernateJptPlugin.java =================================================================== --- trunk/hibernatetools/plugins/org.jboss.tools.hibernate.jpt.core/src/org/jboss/tools/hibernate/jpt/core/internal/HibernateJptPlugin.java (rev 0) +++ trunk/hibernatetools/plugins/org.jboss.tools.hibernate.jpt.core/src/org/jboss/tools/hibernate/jpt/core/internal/HibernateJptPlugin.java 2009-02-10 15:12:00 UTC (rev 13561) @@ -0,0 +1,89 @@ +/******************************************************************************* + * Copyright (c) 2007-2008 Red Hat, Inc. + * Distributed under license by Red Hat, Inc. All rights reserved. + * This program is 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 + * + * Contributor: + * Red Hat, Inc. - initial API and implementation + ******************************************************************************/ +package org.jboss.tools.hibernate.jpt.core.internal; + +import java.util.ArrayList; +import java.util.List; + +import org.eclipse.core.runtime.IStatus; +import org.eclipse.core.runtime.MultiStatus; +import org.eclipse.core.runtime.Plugin; +import org.eclipse.core.runtime.Status; +import org.hibernate.eclipse.console.HibernateConsoleMessages; +import org.hibernate.eclipse.logging.LoggingHelper; +import org.hibernate.eclipse.logging.xpl.EclipseLogger; +import org.osgi.framework.BundleContext; + +/** + * @author Dmitry Geraskov + * + */ +public class HibernateJptPlugin extends Plugin { + + public static final String ID = "org.jboss.tools.hibernate.jpt.core"; //$NON-NLS-1$ + + private EclipseLogger logger; + + private static HibernateJptPlugin inst; + + public static HibernateJptPlugin getDefault() { + return inst; + } + + /** + * Log message + * + */ + private static void log(int severity, String message, Throwable e) { + getDefault().getLog().log(new Status(severity, ID, message, e)); + } + + /** + * Short exception log + * + */ + public static void logException(Throwable e) { + log(IStatus.ERROR, e.getMessage(), e); + } + + /** + * Short exception log + * + */ + public static void logException(String message, Throwable e) { + log(IStatus.ERROR, message, e); + } + + /** + * Short error log call + * + */ + public static void logError(String message) { + log(IStatus.ERROR, message, null); + } + + /** + * Short warning log call + * + */ + public static void logWarning(String message) { + log(IStatus.WARNING, message, null); + } + + /** + * Short information log call + * + */ + public static void logInfo(String message) { + log(IStatus.INFO, message, null); + } + +} Property changes on: trunk/hibernatetools/plugins/org.jboss.tools.hibernate.jpt.core/src/org/jboss/tools/hibernate/jpt/core/internal/HibernateJptPlugin.java ___________________________________________________________________ Name: svn:mime-type + text/plain Name: svn:keywords + Author Id Revision Date Name: svn:eol-style + native Modified: trunk/hibernatetools/plugins/org.jboss.tools.hibernate.jpt.core/src/org/jboss/tools/hibernate/jpt/core/internal/JPAPostInstallFasetListener.java =================================================================== --- trunk/hibernatetools/plugins/org.jboss.tools.hibernate.jpt.core/src/org/jboss/tools/hibernate/jpt/core/internal/JPAPostInstallFasetListener.java 2009-02-10 15:11:45 UTC (rev 13560) +++ trunk/hibernatetools/plugins/org.jboss.tools.hibernate.jpt.core/src/org/jboss/tools/hibernate/jpt/core/internal/JPAPostInstallFasetListener.java 2009-02-10 15:12:00 UTC (rev 13561) @@ -50,7 +50,7 @@ return false; } } catch (CoreException e) { - e.printStackTrace(); + HibernateJptPlugin.logException(e); } return true; } @@ -92,7 +92,7 @@ wc.doSave(); ProjectUtils.toggleHibernateOnProject(project, true, launchName); } catch (CoreException e) { - e.printStackTrace(); + HibernateJptPlugin.logException(e); } } Modified: trunk/hibernatetools/plugins/org.jboss.tools.hibernate.jpt.core/src/org/jboss/tools/hibernate/jpt/core/internal/context/HibernatePersistenceUnit.java =================================================================== --- trunk/hibernatetools/plugins/org.jboss.tools.hibernate.jpt.core/src/org/jboss/tools/hibernate/jpt/core/internal/context/HibernatePersistenceUnit.java 2009-02-10 15:11:45 UTC (rev 13560) +++ trunk/hibernatetools/plugins/org.jboss.tools.hibernate.jpt.core/src/org/jboss/tools/hibernate/jpt/core/internal/context/HibernatePersistenceUnit.java 2009-02-10 15:12:00 UTC (rev 13561) @@ -11,7 +11,9 @@ package org.jboss.tools.hibernate.jpt.core.internal.context; import java.io.File; -import java.util.ArrayList; +import java.io.IOException; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; @@ -25,32 +27,27 @@ import org.eclipse.core.resources.ResourcesPlugin; import org.eclipse.core.runtime.IPath; import org.eclipse.core.runtime.Path; -import org.eclipse.jpt.core.context.Generator; -import org.eclipse.jpt.core.context.java.JavaGenerator; +import org.eclipse.jpt.core.JpaProject; import org.eclipse.jpt.core.context.java.JavaPersistentAttribute; import org.eclipse.jpt.core.context.java.JavaPersistentType; import org.eclipse.jpt.core.context.persistence.ClassRef; import org.eclipse.jpt.core.context.persistence.Persistence; import org.eclipse.jpt.core.context.persistence.Property; import org.eclipse.jpt.core.internal.context.persistence.GenericPersistenceUnit; -import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages; -import org.eclipse.jpt.core.internal.validation.JpaValidationMessages; import org.eclipse.jpt.core.resource.java.JavaResourcePersistentAttribute; import org.eclipse.jpt.core.resource.java.JavaResourcePersistentMember; -import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType; import org.eclipse.jpt.core.resource.persistence.XmlPersistenceUnit; import org.eclipse.jpt.core.resource.persistence.XmlProperties; import org.eclipse.jpt.core.resource.persistence.XmlProperty; -import org.eclipse.jpt.core.utility.TextRange; import org.eclipse.jpt.utility.internal.CollectionTools; import org.eclipse.jpt.utility.internal.iterators.CloneIterator; import org.eclipse.jpt.utility.internal.iterators.EmptyIterator; import org.eclipse.wst.validation.internal.core.Message; import org.eclipse.wst.validation.internal.provisional.core.IMessage; +import org.jboss.tools.hibernate.jpt.core.internal.HibernateJptPlugin; import org.jboss.tools.hibernate.jpt.core.internal.context.basic.BasicHibernateProperties; import org.jboss.tools.hibernate.jpt.core.internal.context.basic.Hibernate; import org.jboss.tools.hibernate.jpt.core.internal.context.java.GenericGeneratorAnnotation; -import org.jboss.tools.hibernate.jpt.core.internal.context.java.JavaGenericGenerator; /** * @author Dmitry Geraskov @@ -81,13 +78,18 @@ return this.hibernateProperties.getBasicHibernate(); } - // ********** Validation *********************************************** - @Override + // ********** Validation *********************************************** + public void validate(List<IMessage> messages) { + addToMessages(messages); + } + public void addToMessages(List<IMessage> messages) { - super.addToMessages(messages); + invokeMethod(this, "addMappingFileMessages", "validateMappingFiles", + new Class[]{List.class}, messages); + invokeMethod(this, "addClassMessages", "validateClassRefs", new Class[]{List.class}, messages); addFileNotExistsMessages(messages); - } - + } + protected void addFileNotExistsMessages(List<IMessage> messages) { String configFile = getBasicProperties().getConfigurationFile(); if (configFile != null && configFile.length() > 0){ @@ -171,30 +173,100 @@ @Override public void update(XmlPersistenceUnit persistenceUnit) { super.update(persistenceUnit); - updateGenericGenerators(); + updateGenericGenerators(); } protected void updateGenericGenerators(){ - for (String annotClass : CollectionTools.iterable(getJpaProject().annotatedClassNames())) { + JpaProject project = getJpaProject(); + for (String annotClass : CollectionTools.iterable(project.annotatedClassNames())) { ClassRef classRef = buildClassRef(annotClass); JavaPersistentType type = classRef.getJavaPersistentType(); - JavaResourcePersistentMember jrpt = getJpaProject().getJavaPersistentTypeResource(annotClass); - GenericGeneratorAnnotation annotation = (GenericGeneratorAnnotation) jrpt.getAnnotation(GENERIC_GENERATOR); - if (annotation != null) { - addGenerator(annotation.buildJavaGenericGenerator(type)); + JavaResourcePersistentMember jrpt = null; + GenericGeneratorAnnotation annotation = null; + jrpt = (JavaResourcePersistentMember) invokeMethod(project, "getJavaPersistentTypeResource", + "getJavaResourcePersistentType", new Class[]{String.class}, annotClass); + if (jrpt != null){ + annotation = (GenericGeneratorAnnotation)invokeMethod(jrpt, "getAnnotation", + "getSupportingAnnotation", new Class[]{String.class}, GENERIC_GENERATOR); + if (annotation != null) { + addGenerator(annotation.buildJavaGenericGenerator(type)); + } + ListIterator<JavaPersistentAttribute> typeAttrs = type.attributes(); + for (JavaPersistentAttribute persAttr : CollectionTools.iterable(typeAttrs)) { + JavaResourcePersistentAttribute jrpa = persAttr.getResourcePersistentAttribute(); + annotation = (GenericGeneratorAnnotation)invokeMethod(jrpa, "getAnnotation", + "getSupportingAnnotation", new Class[]{String.class}, GENERIC_GENERATOR); + + if (annotation != null) { + addGenerator(annotation.buildJavaGenericGenerator(persAttr.getSpecifiedMapping())); + } + } + } + } + } + + /** + * Hack method needed to make Hibernate Platform portable between Dali 2.0 and Dali 2.1 + * @param object - object on which method will be called + * @param dali20Name - method name in Dali 2.0 + * @param dali21Name - same method name in Dali 2.1 + * @param paramTypes - method arguments types. + * @param args - arguments of the method + * @return + */ + private Object invokeMethod(Object object, String dali20Name, String dali21Name, Class[] argsTypes, + Object... args){ + Method method = getMethod(object.getClass(), dali20Name, dali21Name, argsTypes); + if (method != null){ + try { + return method.invoke(object, args); + } catch (IllegalArgumentException e) { + HibernateJptPlugin.logException(e); + } catch (IllegalAccessException e) { + HibernateJptPlugin.logException(e); + } catch (InvocationTargetException e) { + HibernateJptPlugin.logException(e); } - - ListIterator<JavaPersistentAttribute> typeAttrs = type.attributes(); - for (JavaPersistentAttribute persAttr : CollectionTools.iterable(typeAttrs)) { - JavaResourcePersistentAttribute jrpa = persAttr.getResourcePersistentAttribute(); - annotation = (GenericGeneratorAnnotation) jrpa.getAnnotation(GENERIC_GENERATOR); - if (annotation != null){ - addGenerator(annotation.buildJavaGenericGenerator(persAttr.getSpecifiedMapping())); - } + } else { + StringBuilder params = new StringBuilder(); + for (int i = 0; i < argsTypes.length; i++) { + params.append(argsTypes[i].getName() + ", "); } + if (params.length() > 0) params.deleteCharAt(params.length() - 2); + HibernateJptPlugin.logError("Nor \"" + dali20Name + "\" nor \"" + dali21Name + + "\" methods were found with parameter types: (" + params + ")"); } + return null; } + + /** + * Hack method needed to make Hibernate Platform portable between Dali 2.0 and Dali 2.1 + * @param parent + * @param dali20Name - method name in Dali 2.0 + * @param dali21Name - same method name in Dali 2.1 + * @param parameterTypes + * @return + */ + private Method getMethod(Class parent, String dali20Name, String dali21Name, Class... parameterTypes){ + Class clazz = parent; + while (clazz != null){ + Method method = null; + try {//try to get method from Dali 2.0 + method = clazz.getDeclaredMethod(dali20Name, parameterTypes); + return method; + } catch (Exception e) { + try {//try to get method from Dali 2.1 + method = clazz.getDeclaredMethod(dali21Name, parameterTypes); + return method; + } catch (Exception e1) { + clazz = clazz.getSuperclass(); + } + } + } + return null; + } + /** * Hack class needed to make JPA/Validation API pick up our classloader instead of its own. * @@ -208,5 +280,5 @@ super(name, highSeverity, notAFile, strings, resource); } } - + } Modified: trunk/hibernatetools/plugins/org.jboss.tools.hibernate.jpt.core/src/org/jboss/tools/hibernate/jpt/core/internal/context/java/GenericGeneratorAnnotationImpl.java =================================================================== --- trunk/hibernatetools/plugins/org.jboss.tools.hibernate.jpt.core/src/org/jboss/tools/hibernate/jpt/core/internal/context/java/GenericGeneratorAnnotationImpl.java 2009-02-10 15:11:45 UTC (rev 13560) +++ trunk/hibernatetools/plugins/org.jboss.tools.hibernate.jpt.core/src/org/jboss/tools/hibernate/jpt/core/internal/context/java/GenericGeneratorAnnotationImpl.java 2009-02-10 15:12:00 UTC (rev 13561) @@ -177,6 +177,11 @@ return generator; } + //for Dali 2.1 + public void update(CompilationUnit astRoot) { + updateFromJava(astRoot); + } + // ********** static methods ********** private static DeclarationAnnotationElementAdapter<String> buildNameAdapter() { return ConversionDeclarationAnnotationElementAdapter.forStrings(DECLARATION_ANNOTATION_ADAPTER, Hibernate.GENERIC_GENERATOR__NAME, false); Modified: trunk/hibernatetools/plugins/org.jboss.tools.hibernate.jpt.core/src/org/jboss/tools/hibernate/jpt/core/internal/context/java/JavaGenericGeneratorImpl.java =================================================================== --- trunk/hibernatetools/plugins/org.jboss.tools.hibernate.jpt.core/src/org/jboss/tools/hibernate/jpt/core/internal/context/java/JavaGenericGeneratorImpl.java 2009-02-10 15:11:45 UTC (rev 13560) +++ trunk/hibernatetools/plugins/org.jboss.tools.hibernate.jpt.core/src/org/jboss/tools/hibernate/jpt/core/internal/context/java/JavaGenericGeneratorImpl.java 2009-02-10 15:12:00 UTC (rev 13561) @@ -10,8 +10,12 @@ ******************************************************************************/ package org.jboss.tools.hibernate.jpt.core.internal.context.java; +import org.eclipse.jdt.core.dom.CompilationUnit; +import org.eclipse.jpt.core.context.Generator; import org.eclipse.jpt.core.context.java.JavaJpaContextNode; import org.eclipse.jpt.core.internal.context.java.AbstractJavaGenerator; +import org.eclipse.jpt.core.resource.java.GeneratorAnnotation; +import org.eclipse.jpt.core.utility.TextRange; /** * @author Dmitry Geraskov @@ -21,6 +25,8 @@ implements JavaGenericGenerator { private String strategy; + + protected GeneratorAnnotation generatorResource; /** * @param parent @@ -29,25 +35,64 @@ super(parent); } - @Override protected GenericGeneratorAnnotation getGeneratorResource() { - return (GenericGeneratorAnnotation) super.getGeneratorResource(); + return (GenericGeneratorAnnotation) generatorResource; } public Integer getDefaultInitialValue() { return GenericGenerator.DEFAULT_INITIAL_VALUE; } + protected GeneratorAnnotation getResourceGenerator() { + return this.generatorResource; + } + public void initializeFromResource(GenericGeneratorAnnotation generator) { - super.initializeFromResource(generator); - this.strategy = generator.getStrategy(); + generatorResource = generator; + this.name = generator.getName(); + this.specifiedInitialValue = generator.getInitialValue(); + this.specifiedAllocationSize = generator.getAllocationSize(); + this.strategy = generator.getStrategy(); } public void update(GenericGeneratorAnnotation generator) { - super.update(generator); - setSpecifiedStrategy_(generator.getStrategy()); + this.generatorResource = generator; + this.setName_(generator.getName()); + this.setSpecifiedInitialValue_(generator.getInitialValue()); + this.setSpecifiedAllocationSize_(generator.getAllocationSize()); + this.setSpecifiedStrategy_(generator.getStrategy()); + //getPersistenceUnit().addGenerator(this); } + public void setName(String name) { + String old = this.name; + this.name = name; + this.generatorResource.setName(name); + this.firePropertyChanged(Generator.NAME_PROPERTY, old, name); + } + + public void setSpecifiedInitialValue(Integer specifiedInitialValue) { + Integer old = this.specifiedInitialValue; + this.specifiedInitialValue = specifiedInitialValue; + this.generatorResource.setInitialValue(specifiedInitialValue); + this.firePropertyChanged(Generator.SPECIFIED_INITIAL_VALUE_PROPERTY, old, specifiedInitialValue); + } + + public void setSpecifiedAllocationSize(Integer specifiedAllocationSize) { + Integer old = this.specifiedAllocationSize; + this.specifiedAllocationSize = specifiedAllocationSize; + this.generatorResource.setAllocationSize(specifiedAllocationSize); + this.firePropertyChanged(Generator.SPECIFIED_ALLOCATION_SIZE_PROPERTY, old, specifiedAllocationSize); + } + + public TextRange getSelectionTextRange(CompilationUnit astRoot) { + return this.generatorResource.getTextRange(astRoot); + } + + public TextRange getNameTextRange(CompilationUnit astRoot) { + return this.generatorResource.getNameTextRange(astRoot); + } + public String getStrategy() { return strategy; } @@ -65,4 +110,12 @@ firePropertyChanged(GENERIC_STRATEGY_PROPERTY, oldStrategy, strategy); } + protected String getCatalog() { + return null; + } + + protected String getSchema() { + return null; + } + }