Index: src/test/java/org/castor/jpa/ClassInfoBuilderTest.java =================================================================== --- src/test/java/org/castor/jpa/ClassInfoBuilderTest.java (revision 0) +++ src/test/java/org/castor/jpa/ClassInfoBuilderTest.java (revision 0) @@ -0,0 +1,72 @@ +package org.castor.jpa; + +import javax.persistence.*; + +import junit.framework.Assert; +import junit.framework.TestCase; + +public class ClassInfoBuilderTest extends TestCase { + + private ClassInfoBuilder _classBuilder; + + public void setUp(){ + _classBuilder = new ClassInfoBuilder(); + _classBuilder.set_classAnnotationProcessingService(new ClassAnnotationProcessingService()); + } + + @Entity(name = "JPAentityTEST") + @Table(name = "JPAtableTEST", schema="TESTschema", catalog="TESTcatalog") + private class Jpatest{ + @Column(name = "JPAcolumnTESTbla", unique=true, nullable=false, insertable=true, updatable=true, columnDefinition="TESTDefinitionBla", table="JPAtableTEST", length=10, precision=100, scale=1000) + private String bla; + @Column(name = "JPAcolumnTESTblob", unique=false, nullable=true, insertable=false, updatable=false, columnDefinition="TESTDefinitionBlob", table="JPAtableTEST", length=2000, precision=200, scale=20) + private String blob; + } + + private class JpaNullTest{ + private String blubb; + } + + public void testJpatest(){ + + ClassInfo classInfo = _classBuilder.buildClassInfo(Jpatest.class); + + Assert.assertEquals("JPAentityTEST", classInfo.getEntityName()); + + Assert.assertEquals("JPAtableTEST", classInfo.getTableName()); + Assert.assertEquals("TESTschema", classInfo.getTableSchema()); + Assert.assertEquals("TESTcatalog", classInfo.getTableCatalog()); + + Assert.assertNotNull(classInfo.getFieldInfo("bla")); + Assert.assertEquals("JPAcolumnTESTbla", classInfo.getFieldInfo("bla").getColumnName()); + Assert.assertEquals(true, classInfo.getFieldInfo("bla").getColumnUnique()); + Assert.assertEquals(false, classInfo.getFieldInfo("bla").getColumnNullable()); + Assert.assertEquals(true, classInfo.getFieldInfo("bla").getColumnInsertable()); + Assert.assertEquals(true, classInfo.getFieldInfo("bla").getColumnUpdateable()); + Assert.assertEquals("TESTDefinitionBla", classInfo.getFieldInfo("bla").getColumnDefinition()); + Assert.assertEquals("JPAtableTEST", classInfo.getFieldInfo("bla").getColumnTable()); + Assert.assertEquals(10, classInfo.getFieldInfo("bla").getColumnLength()); + Assert.assertEquals(100, classInfo.getFieldInfo("bla").getColumnPrecision()); + Assert.assertEquals(1000, classInfo.getFieldInfo("bla").getColumnScale()); + + Assert.assertNotNull(classInfo.getFieldInfo("blob")); + Assert.assertEquals("JPAcolumnTESTblob", classInfo.getFieldInfo("blob").getColumnName()); + Assert.assertEquals(false, classInfo.getFieldInfo("blob").getColumnUnique()); + Assert.assertEquals(true, classInfo.getFieldInfo("blob").getColumnNullable()); + Assert.assertEquals(false, classInfo.getFieldInfo("blob").getColumnInsertable()); + Assert.assertEquals(false, classInfo.getFieldInfo("blob").getColumnUpdateable()); + Assert.assertEquals("TESTDefinitionBlob", classInfo.getFieldInfo("blob").getColumnDefinition()); + Assert.assertEquals("JPAtableTEST", classInfo.getFieldInfo("blob").getColumnTable()); + Assert.assertEquals(2000, classInfo.getFieldInfo("blob").getColumnLength()); + Assert.assertEquals(200, classInfo.getFieldInfo("blob").getColumnPrecision()); + Assert.assertEquals(20, classInfo.getFieldInfo("blob").getColumnScale()); + + } + + public void testJpaNullTest(){ + ClassInfo classInfo = _classBuilder.buildClassInfo(JpaNullTest.class); + + Assert.assertNull(classInfo.getFieldInfo("blubb").getColumnName()); + } + +} Index: src/main/java/org/castor/jpa/FieldInfo.java =================================================================== --- src/main/java/org/castor/jpa/FieldInfo.java (revision 0) +++ src/main/java/org/castor/jpa/FieldInfo.java (revision 0) @@ -0,0 +1,164 @@ +package org.castor.jpa; + +import java.util.HashMap; +import java.util.Map; + +public class FieldInfo{ + + private String _fieldName; + + private Map _properties = new HashMap(); + + public FieldInfo(final String fieldName) { + _fieldName = fieldName; + } + + public String getFieldName() { + return _fieldName; + } + + public final Object getProperty(final String name){ + return _properties.get(name); + } + + public final void setProperty(final String name, final Object value){ + _properties.put(name, value); + } + + public void setColumnName(String columnName) { + setProperty(FieldProperties.COLUMN_NAME, columnName); + } + + public String getColumnName(){ + return (String) getProperty(FieldProperties.COLUMN_NAME); + } + + public void setColumnDefinition(String columnDefinition) { + setProperty(FieldProperties.COlUMN_DEFINITION, columnDefinition); + } + + public String getColumnDefinition(){ + return (String) getProperty(FieldProperties.COlUMN_DEFINITION); + } + + public void setColumnLength(int columnLength) { + setProperty(FieldProperties.COLUMN_LENGTH, columnLength); + } + + public int getColumnLength(){ + return (Integer) getProperty(FieldProperties.COLUMN_LENGTH); + } + + public void setColumnInsertable(boolean columnInsertable) { + setProperty(FieldProperties.COLUMN_INSERTABLE, columnInsertable); + } + + public boolean getColumnInsertable(){ + return (Boolean) getProperty(FieldProperties.COLUMN_INSERTABLE); + } + + public void setColumnNullable(boolean columnNullable) { + setProperty(FieldProperties.COLUMN_NULLABLE, columnNullable); + } + + public boolean getColumnNullable(){ + return (Boolean) getProperty(FieldProperties.COLUMN_NULLABLE); + } + + public void setColumnPrecision(int columnPrecision) { + setProperty(FieldProperties.COLUMN_PRECISION, columnPrecision); + } + + public int getColumnPrecision(){ + return (Integer) getProperty(FieldProperties.COLUMN_PRECISION); + } + + public void setColumnScale(int columnScale) { + setProperty(FieldProperties.COLUMN_SCALE, columnScale); + } + + public int getColumnScale(){ + return (Integer) getProperty(FieldProperties.COLUMN_SCALE); + } + + public void setColumnTable(String columnTable) { + setProperty(FieldProperties.COlUMN_TABLE, columnTable); + } + + public String getColumnTable(){ + return (String) getProperty(FieldProperties.COlUMN_TABLE); + } + + public void setColumnUnique(boolean columnUnique) { + setProperty(FieldProperties.COLUMN_UNIQUE, columnUnique); + + } + + public boolean getColumnUnique(){ + return (Boolean) getProperty(FieldProperties.COLUMN_UNIQUE); + } + + public void setColumnUpdateable(boolean columnUpdatable) { + setProperty(FieldProperties.COLUMN_UPDATEABLE, columnUpdatable); + + } + + public boolean getColumnUpdateable(){ + return (Boolean) getProperty(FieldProperties.COLUMN_UPDATEABLE); + } + + static interface FieldProperties { + + /** + * Name of the Column + */ + String COLUMN_NAME = "COLUMN_NAME"; + + /** + * Definition of the Column + */ + String COlUMN_DEFINITION = "COLUMN_DEFINITION"; + + /** + * Insertable + */ + String COLUMN_INSERTABLE = "COLUMN_INSERTABLE"; + + /** + * Length + */ + String COLUMN_LENGTH = "COLUMN_LENGTH"; + + /** + * Nullable + */ + String COLUMN_NULLABLE = "COLUMN_NULLABLE"; + + /** + * Precision + */ + String COLUMN_PRECISION = "COLUMN_PRECISION"; + + /** + * Scale + */ + String COLUMN_SCALE = "COLUMN_SCALE"; + + /** + * Table NAme + */ + String COlUMN_TABLE = "COLUMN_TABLE"; + + /** + * Unique + */ + String COLUMN_UNIQUE = "COLUMN_UNIQUE"; + + /** + * Updateable + */ + String COLUMN_UPDATEABLE = "COLUMN_UPDATEABLE"; + + } + +} Index: src/main/java/org/castor/jpa/ClassInfo.java =================================================================== --- src/main/java/org/castor/jpa/ClassInfo.java (revision 0) +++ src/main/java/org/castor/jpa/ClassInfo.java (revision 0) @@ -0,0 +1,124 @@ +package org.castor.jpa; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +public class ClassInfo{ + + private String _className; + + private List _fieldInfos = new ArrayList(); + + private PackageInfo _packageInfo; + + private Map _properties = new HashMap(); + + public ClassInfo(final String className){ + _className = className; + } + + public String getClassName(){ + return _className; + } + + public final void addFieldInfo(final FieldInfo fieldInfo){ + _fieldInfos.add(fieldInfo); + } + + public final List getFieldInfos(){ + return _fieldInfos; + } + + public FieldInfo getFieldInfo(final String fieldName) { + FieldInfo foundFieldInfo = null; + for (FieldInfo fi : _fieldInfos) { + if (fi.getFieldName().equals(fieldName)) { + foundFieldInfo = fi; + } + } + return foundFieldInfo; + } + + public final PackageInfo getPackageInfo() { + return _packageInfo; + } + + public final void setPackageInfo(final PackageInfo packageInfo) { + _packageInfo = packageInfo; + } + public final Object getProperty(final String name) { + return _properties.get(name); + } + public final void setProperty(final String name, final Object value) { + _properties.put(name, value); + } + + + public String getEntityName(){ + return (String) getProperty(ClassProperties.ENTITY_NAME); + } + + public void setEntityName(final String entityName){ + setProperty(ClassProperties.ENTITY_NAME, entityName); + } + + public String getTableName(){ + return (String) getProperty(ClassProperties.TABLE_NAME); + } + + public void setTableName(final String tableName){ + setProperty(ClassProperties.TABLE_NAME, tableName); + } + + public String getTableCatalog(){ + return (String) getProperty(ClassProperties.TABLE_CATALOG); + } + + public void setTableCatalog(final String tableCatalog){ + setProperty(ClassProperties.TABLE_CATALOG, tableCatalog); + } + + public String getTableSchema(){ + return (String) getProperty(ClassProperties.TABLE_SCHEMA); + } + + public void setTableSchema(final String tableSchema){ + setProperty(ClassProperties.TABLE_SCHEMA, tableSchema); + } + +//TODO public getTableUniqueConstraints(){} + +//TODO public void setTableUniqueConstraints(final String uniqueConstraints){ setProperty(ClassProperties.TABLE_UNIQUE_CONSTRAINTS, uniqueConstraints); } + + + + static interface ClassProperties { + /** + * Name of the Entity + */ + String ENTITY_NAME = "ENTITY_NAME"; + + /** + * Name of the Table + */ + String TABLE_NAME = "TABLE_NAME"; + + /** + * Catalog of the Table + */ + String TABLE_CATALOG = "TABLE_CATALOG"; + + /** + * Schema of the Table + */ + String TABLE_SCHEMA = "TABLE_SCHEMA"; + + /** + * Unique Constraints of the Table (ColumnNames) + */ + //TODO + } + +} Index: src/main/java/org/castor/jpa/JpaTableProcessor.java =================================================================== --- src/main/java/org/castor/jpa/JpaTableProcessor.java (revision 0) +++ src/main/java/org/castor/jpa/JpaTableProcessor.java (revision 0) @@ -0,0 +1,27 @@ +package org.castor.jpa; + +import java.lang.annotation.Annotation; + +import javax.persistence.Table; + + +public class JpaTableProcessor implements AnnotationProcessor { + + public Class forAnnotationClass() { + return Table.class; + } + + public void processAnnotation(I info, A annotation) { + if(info instanceof ClassInfo){ + ClassInfo classInfo = (ClassInfo) info; + + if((annotation instanceof Table)){ + Table table = (Table) annotation; + classInfo.setTableName(table.name()); + classInfo.setTableCatalog(table.catalog()); + classInfo.setTableSchema(table.schema()); + //TODO UniqueConstraints + } + } + } +} Index: src/main/java/org/castor/jpa/PackageInfo.java =================================================================== --- src/main/java/org/castor/jpa/PackageInfo.java (revision 0) +++ src/main/java/org/castor/jpa/PackageInfo.java (revision 0) @@ -0,0 +1,28 @@ +package org.castor.jpa; + +import java.util.HashMap; +import java.util.Map; + +public class PackageInfo { + + private String _packageName; + + private Map _properties = new HashMap(); + + public PackageInfo(final String packageName){ + _packageName = packageName; + } + + public String getPackageName(){ + return _packageName; + } + + public final Object getProperty(final String name){ + return _properties.get(name); + } + + public final void setProperty(final String name, final Object value){ + _properties.put(name, value); + } + +} Index: src/main/java/org/castor/jpa/JpaEntityProcessor.java =================================================================== --- src/main/java/org/castor/jpa/JpaEntityProcessor.java (revision 0) +++ src/main/java/org/castor/jpa/JpaEntityProcessor.java (revision 0) @@ -0,0 +1,23 @@ +package org.castor.jpa; + +import java.lang.annotation.Annotation; + +import javax.persistence.Entity; + +public class JpaEntityProcessor implements AnnotationProcessor { + + public Class forAnnotationClass() { + return Entity.class; + } + + public void processAnnotation(I info, A annotation) { + if (info instanceof ClassInfo) { + ClassInfo classInfo = (ClassInfo) info; + if (annotation instanceof Entity){ + Entity entity = (Entity) annotation; + classInfo.setEntityName(entity.name()); + } + } + + } +} Index: src/main/java/org/castor/jpa/AnnotationProcessingService.java =================================================================== --- src/main/java/org/castor/jpa/AnnotationProcessingService.java (revision 0) +++ src/main/java/org/castor/jpa/AnnotationProcessingService.java (revision 0) @@ -0,0 +1,35 @@ +package org.castor.jpa; + +import java.lang.annotation.Annotation; +import java.util.HashMap; +import java.util.Map; + +public class AnnotationProcessingService { + + + private Map < Class < ? extends Annotation > , AnnotationProcessor > _annotationProcessorMap = + new HashMap < Class < ? extends Annotation > , AnnotationProcessor > (); + + protected final void addAnnotationProcessor(final AnnotationProcessor annotationProcessor) { + if (annotationProcessor != null) { + _annotationProcessorMap.put( + annotationProcessor.forAnnotationClass(), + annotationProcessor); + } + } + public void processAnnotation(ClassInfo classInfo, A annotation) { + AnnotationProcessor annotationProcessor = + _annotationProcessorMap.get(annotation.annotationType()); + if (annotationProcessor != null) { + annotationProcessor.processAnnotation(classInfo, annotation); + } else { + //TODO + } + + } + + public AnnotationProcessor getAnnotationProcessor(Annotation annotation) { + Class annotationType = annotation.annotationType(); + return this._annotationProcessorMap.get(annotationType); + } +} Index: src/main/java/org/castor/jpa/JpaColumnProcessor.java =================================================================== --- src/main/java/org/castor/jpa/JpaColumnProcessor.java (revision 0) +++ src/main/java/org/castor/jpa/JpaColumnProcessor.java (revision 0) @@ -0,0 +1,32 @@ +package org.castor.jpa; + +import java.lang.annotation.Annotation; + +import javax.persistence.Column; + +public class JpaColumnProcessor implements AnnotationProcessor{ + + public Class forAnnotationClass() { + return Column.class; + } + + public void processAnnotation(I info, A annotation) { + if(info instanceof FieldInfo){ + FieldInfo fieldInfo = (FieldInfo) info; + + if(annotation instanceof Column){ + Column column = (Column) annotation; + fieldInfo.setColumnName(column.name()); + fieldInfo.setColumnDefinition(column.columnDefinition()); + fieldInfo.setColumnLength(column.length()); + fieldInfo.setColumnInsertable(column.insertable()); + fieldInfo.setColumnNullable(column.nullable()); + fieldInfo.setColumnPrecision(column.precision()); + fieldInfo.setColumnScale(column.scale()); + fieldInfo.setColumnTable(column.table()); + fieldInfo.setColumnUnique(column.unique()); + fieldInfo.setColumnUpdateable(column.updatable()); + } + } + } +} Index: src/main/java/org/castor/jpa/ClassInfoBuilder.java =================================================================== --- src/main/java/org/castor/jpa/ClassInfoBuilder.java (revision 0) +++ src/main/java/org/castor/jpa/ClassInfoBuilder.java (revision 0) @@ -0,0 +1,183 @@ +package org.castor.jpa; + +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.lang.reflect.Modifier; + + +public class ClassInfoBuilder { + + private ClassAnnotationProcessingService _classAnnotationProcessingService; + + //TODO private PackageAnnotationProcessingService _packageAnnotationProcessingService; + + private FieldAnnotationProcessingService _fieldAnnotationProcessingService; + + public ClassAnnotationProcessingService get_classAnnotationProcessingService() { + return _classAnnotationProcessingService; + } + + public void set_classAnnotationProcessingService( + ClassAnnotationProcessingService annotationProcessingService) { + _classAnnotationProcessingService = annotationProcessingService; + } + + public FieldAnnotationProcessingService get_fieldAnnotationProcessingService() { + return _fieldAnnotationProcessingService; + } + + public void set_fieldAnnotationProcessingService(FieldAnnotationProcessingService annotationProcessingService){ + _fieldAnnotationProcessingService = annotationProcessingService; + } + + public ClassInfoBuilder(){ + _classAnnotationProcessingService = new ClassAnnotationProcessingService(); + _fieldAnnotationProcessingService = new FieldAnnotationProcessingService(); + } + + public ClassInfo buildClassInfo(final Class type){ + + if(type == null){ + String msg = "Argument type must not be null"; + throw new IllegalArgumentException(msg); + } + + if(!isDescribeable(type)){ + return null; + } + + ClassInfo classInfo = createClassInfo(type.getName()); + + _classAnnotationProcessingService.processAnnotations(classInfo, type.getAnnotations()); + + for (Field field : type.getDeclaredFields()) { + if(isDescribeable(type, field)){ + classInfo = buildFieldInfo(classInfo, field); + }else{ + //TODO + } + } + + for(Method method : type.getDeclaredMethods()){ + if(isDescribeable(type, method)){ + classInfo = buildFieldInfo(classInfo, method); + }else{ + //TODO + } + } + + PackageInfo packageInfo = buildPackageInfo(type.getPackage()); + classInfo.setPackageInfo(packageInfo); + + return classInfo; + } + + private boolean isDescribeable(final Class type, final Method method) { + boolean isDescribeable = true; + Class declaringClass = method.getDeclaringClass(); + + if ((declaringClass != null) && (!type.equals(declaringClass)) && (!declaringClass.isInterface())){ + isDescribeable = false; + } + if (method.isSynthetic()){ + isDescribeable &= false; + } + if (Modifier.isStatic(method.getModifiers())){ + isDescribeable &= false; + } + if (Modifier.isTransient(method.getModifiers())){ + isDescribeable &= false; + } + return isDescribeable; + } + + private ClassInfo buildFieldInfo(ClassInfo classInfo, Method method) { + if (classInfo == null) { + String message = "Argument classInfo must not be null."; + throw new IllegalArgumentException(message); + } + ClassInfo returnClassInfo = classInfo; + if (method == null) { + String message = "Argument method must not be null."; + throw new IllegalArgumentException(message); + } + String fieldName = method.getName(); + FieldInfo fieldInfo = returnClassInfo.getFieldInfo(fieldName); + if (fieldInfo == null) { + fieldInfo = createFieldInfo(fieldName); + returnClassInfo.addFieldInfo(fieldInfo); + } + //_fieldAnnotationProcessingService.processAnnotations(method.getAnnotations()); + return returnClassInfo; + } + + private PackageInfo buildPackageInfo(Package pkg) { + PackageInfo packageInfo = createPackageInfo(pkg.getName()); + //TODO _packageAnnotationProcessingService.processAnnotations(pkg.getAnnotations()); + return packageInfo; + } + + private PackageInfo createPackageInfo(String packageName) { + PackageInfo packageInfo = new PackageInfo(packageName); + return packageInfo; + } + + private ClassInfo buildFieldInfo(ClassInfo classInfo, Field field) { + if (classInfo == null) { + String message = "Argument classInfo must not be null."; + throw new IllegalArgumentException(message); + } + ClassInfo returnClassInfo = classInfo; + if (field == null) { + String message = "Argument field must not be null."; + throw new IllegalArgumentException(message); + } + String fieldName = field.getName(); + FieldInfo returnFieldInfo = returnClassInfo.getFieldInfo(fieldName); + if (field != null) { + returnFieldInfo = createFieldInfo(fieldName); + returnClassInfo.addFieldInfo(returnFieldInfo); + } + Class fieldType = field.getDeclaringClass(); + _fieldAnnotationProcessingService.processAnnotations(returnFieldInfo, field.getAnnotations()); + returnClassInfo.addFieldInfo(returnFieldInfo); + return returnClassInfo; + } + + private FieldInfo createFieldInfo(String fieldName) { + FieldInfo fieldInfo = new FieldInfo(fieldName); + return fieldInfo; + } + + private boolean isDescribeable(Class type, Field field) { + boolean isDescribeable = true; + Class declaringClass = field.getDeclaringClass(); + if ((declaringClass != null) && !type.equals(declaringClass) + && (!declaringClass.isInterface())) { + isDescribeable = false; + } + if (Modifier.isStatic(field.getModifiers())) { + isDescribeable &= false; + } + if (Modifier.isTransient(field.getModifiers())) { + isDescribeable &= false; + } + if (field.isSynthetic()) { + isDescribeable &= false; + } + return isDescribeable; + } + + private ClassInfo createClassInfo(String className) { + ClassInfo classInfo = new ClassInfo(className); + return classInfo; + } + + private boolean isDescribeable(final Class type) { + if (Object.class.equals(type) || Void.class.equals(type) || Class.class.equals(type)){ + return false; + } + return true; + } + +} Index: src/main/java/org/castor/jpa/AnnotationProcessor.java =================================================================== --- src/main/java/org/castor/jpa/AnnotationProcessor.java (revision 0) +++ src/main/java/org/castor/jpa/AnnotationProcessor.java (revision 0) @@ -0,0 +1,11 @@ +package org.castor.jpa; + +import java.lang.annotation.Annotation; + +public interface AnnotationProcessor { + + Class < ? extends Annotation > forAnnotationClass(); + + void processAnnotation(I info, final A annotation); + +} Index: src/main/java/org/castor/jpa/Info.java =================================================================== --- src/main/java/org/castor/jpa/Info.java (revision 0) +++ src/main/java/org/castor/jpa/Info.java (revision 0) @@ -0,0 +1,10 @@ +package org.castor.jpa; + +public abstract class Info { + private String _infoName; + + public Info(String name){ + _infoName = name; + } + +} Index: src/main/java/org/castor/jpa/FieldAnnotationProcessingService.java =================================================================== --- src/main/java/org/castor/jpa/FieldAnnotationProcessingService.java (revision 0) +++ src/main/java/org/castor/jpa/FieldAnnotationProcessingService.java (revision 0) @@ -0,0 +1,19 @@ +package org.castor.jpa; + +import java.lang.annotation.Annotation; + +public class FieldAnnotationProcessingService extends AnnotationProcessingService{ + + public FieldAnnotationProcessingService() { + addAnnotationProcessor(new JpaColumnProcessor()); + } + + public void processAnnotations(FieldInfo fieldInfo, Annotation[] annotations) { + for (Annotation annotation : annotations) { + AnnotationProcessor processor = super.getAnnotationProcessor(annotation); + if (processor != null) + processor.processAnnotation(fieldInfo, annotation); + } + } + +} Index: src/main/java/org/castor/jpa/ClassAnnotationProcessingService.java =================================================================== --- src/main/java/org/castor/jpa/ClassAnnotationProcessingService.java (revision 0) +++ src/main/java/org/castor/jpa/ClassAnnotationProcessingService.java (revision 0) @@ -0,0 +1,20 @@ +package org.castor.jpa; + +import java.lang.annotation.Annotation; + +public class ClassAnnotationProcessingService extends AnnotationProcessingService{ + + public ClassAnnotationProcessingService(){ + addAnnotationProcessor(new JpaEntityProcessor()); + addAnnotationProcessor(new JpaTableProcessor()); + } + + public void processAnnotations(ClassInfo classInfo, Annotation[] annotations) { + for (Annotation annotation : annotations) { + AnnotationProcessor processor = super.getAnnotationProcessor(annotation); + if (processor != null) + processor.processAnnotation(classInfo, annotation); + } + + } +} Index: pom.xml =================================================================== --- pom.xml (revision 7970) +++ pom.xml (working copy) @@ -1,5 +1,6 @@ - + 4.0.0 org.codehaus.castor castor-jaxb @@ -163,11 +164,9 @@ jaxb-api 2.1 - @@ -187,6 +186,17 @@ 2.3 test + + + javax.persistence + persistence-api + 1.0 + @@ -230,12 +240,12 @@ 1.5 1.5 @@ -303,19 +313,12 @@ org.apache.maven.plugins maven-surefire-plugin @@ -373,16 +376,12 @@ - org.codehaus.mojo