[hibernate-commits] Hibernate SVN: r17068 - in jpamodelgen/trunk/generator/src/main/java/org/hibernate/jpa/metamodel/ap: annotation and 1 other directory.
hibernate-commits at lists.jboss.org
hibernate-commits at lists.jboss.org
Fri Jul 10 11:50:21 EDT 2009
Author: epbernard
Date: 2009-07-10 11:50:21 -0400 (Fri, 10 Jul 2009)
New Revision: 17068
Modified:
jpamodelgen/trunk/generator/src/main/java/org/hibernate/jpa/metamodel/ap/Context.java
jpamodelgen/trunk/generator/src/main/java/org/hibernate/jpa/metamodel/ap/annotation/MetaEntity.java
Log:
Support AccessType for emdebbale (ie propery inheritance by enclosing type)
Modified: jpamodelgen/trunk/generator/src/main/java/org/hibernate/jpa/metamodel/ap/Context.java
===================================================================
--- jpamodelgen/trunk/generator/src/main/java/org/hibernate/jpa/metamodel/ap/Context.java 2009-07-10 15:04:18 UTC (rev 17067)
+++ jpamodelgen/trunk/generator/src/main/java/org/hibernate/jpa/metamodel/ap/Context.java 2009-07-10 15:50:21 UTC (rev 17068)
@@ -16,12 +16,17 @@
*/
public class Context {
//used to cache access types
- private Map<TypeElement, AccessType> accessTypes = new HashMap<TypeElement,AccessType>();
+ private Map<TypeElement, AccessTypeHolder> accessTypes = new HashMap<TypeElement, AccessTypeHolder>();
private Set<String> elementsAlreadyProcessed = new HashSet<String>();
private ProcessingEnvironment pe;
private final Map<String, IMetaEntity> metaEntitiesToProcess = new HashMap<String, IMetaEntity>();
private final Map<String, IMetaEntity> metaSuperclassAndEmbeddableToProcess = new HashMap<String, IMetaEntity>();
+ private static class AccessTypeHolder {
+ public AccessType elementAccessType;
+ public AccessType hierarchyAccessType;
+ }
+
public Context(ProcessingEnvironment pe) {
this.pe = pe;
}
@@ -35,13 +40,33 @@
}
public void addAccessType(TypeElement element, AccessType accessType) {
- accessTypes.put( element, accessType );
+ AccessTypeHolder typeHolder = accessTypes.get( element );
+ if ( typeHolder == null ) {
+ typeHolder = new AccessTypeHolder();
+ accessTypes.put( element, typeHolder );
+ }
+ typeHolder.elementAccessType = accessType;
}
- public Map<TypeElement, AccessType> getAccessTypes() {
- return accessTypes;
+ public void addAccessTypeForHierarchy(TypeElement element, AccessType accessType) {
+ AccessTypeHolder typeHolder = accessTypes.get( element );
+ if ( typeHolder == null ) {
+ typeHolder = new AccessTypeHolder();
+ accessTypes.put( element, typeHolder );
+ }
+ typeHolder.hierarchyAccessType = accessType;
}
+ public AccessType getAccessType(TypeElement element) {
+ final AccessTypeHolder typeHolder = accessTypes.get( element );
+ return typeHolder != null ? typeHolder.elementAccessType : null;
+ }
+
+ public AccessType getDefaultAccessTypeForHerarchy(TypeElement element) {
+ final AccessTypeHolder typeHolder = accessTypes.get( element );
+ return typeHolder != null ? typeHolder.hierarchyAccessType : null;
+ }
+
public Set<String> getElementsAlreadyProcessed() {
return elementsAlreadyProcessed;
}
Modified: jpamodelgen/trunk/generator/src/main/java/org/hibernate/jpa/metamodel/ap/annotation/MetaEntity.java
===================================================================
--- jpamodelgen/trunk/generator/src/main/java/org/hibernate/jpa/metamodel/ap/annotation/MetaEntity.java 2009-07-10 15:04:18 UTC (rev 17067)
+++ jpamodelgen/trunk/generator/src/main/java/org/hibernate/jpa/metamodel/ap/annotation/MetaEntity.java 2009-07-10 15:50:21 UTC (rev 17068)
@@ -27,6 +27,7 @@
import javax.persistence.Embedded;
import javax.persistence.Embeddable;
import javax.persistence.Access;
+import javax.persistence.ElementCollection;
import javax.tools.Diagnostic.Kind;
import javax.tools.Diagnostic;
@@ -46,6 +47,7 @@
private Context context;
//used to propagate the access type of the root entity over to subclasses, superclasses and embeddable
private AccessType defaultAccessTypeForHierarchy;
+ private AccessType defaultAccessTypeForElement;
public MetaEntity(ProcessingEnvironment pe, TypeElement element, Context context) {
this.element = element;
@@ -79,6 +81,7 @@
public List<IMetaAttribute> getMembers() {
List<IMetaAttribute> membersFound = new ArrayList<IMetaAttribute>();
final AccessType elementAccessType = getAccessTypeForElement();
+
List<? extends Element> fieldsOfClass = ElementFilter.fieldsIn( element.getEnclosedElements() );
addPersistentMembers( membersFound, elementAccessType, fieldsOfClass, AccessType.FIELD );
@@ -93,6 +96,7 @@
break; //will be handled or has been handled already
}
else if ( superclass.getAnnotation( MappedSuperclass.class ) != null ) {
+ //FIXME use the class defalut access type
context.processElement( superclass, defaultAccessTypeForHierarchy );
}
}
@@ -136,61 +140,59 @@
}
private AccessType getAccessTypeForElement() {
- //default strategy has more power than local discovery
- //particularly @MappedSuperclass and @Embedded have defaultAccessTypeForHierarchy already filled
- if ( this.defaultAccessTypeForHierarchy != null ) {
- return defaultAccessTypeForHierarchy;
- }
//get local strategy
AccessType accessType = getAccessTypeForClass(element);
- if (accessType != null) {
- this.defaultAccessTypeForHierarchy = accessType;
- return accessType;
+ if (accessType == null) {
+ accessType = this.defaultAccessTypeForHierarchy;
}
-
- //we dont' know
- //if an enity go up
- //
- //superclasses alre always treated after their entities
- //and their access type are discovered
- //FIXME is it really true if only the superclass is changed
- TypeElement superClass = element;
- do {
- superClass = TypeUtils.getSuperclass( superClass );
- if (superClass != null) {
- if ( superClass.getAnnotation( Entity.class ) != null ) {
- //FIXME make it work for XML
- accessType = getAccessTypeForClass(superClass);
- if ( accessType != null ) {
- this.defaultAccessTypeForHierarchy = accessType;
- return accessType;
+ if (accessType == null) {
+ //we dont' know
+ //if an enity go up
+ //
+ //superclasses alre always treated after their entities
+ //and their access type are discovered
+ //FIXME is it really true if only the superclass is changed
+ TypeElement superClass = element;
+ do {
+ superClass = TypeUtils.getSuperclass( superClass );
+ if (superClass != null) {
+ if ( superClass.getAnnotation( Entity.class ) != null
+ || superClass.getAnnotation( MappedSuperclass.class ) != null ) {
+ //FIXME make it work for XML
+ AccessType superClassAccessType = getAccessTypeForClass(superClass);
+ //we've reach the root entity and resolved Ids
+ if ( superClassAccessType != null && defaultAccessTypeForHierarchy != null) {
+ break; //we've found it
+ }
}
- }
- else if ( superClass.getAnnotation( MappedSuperclass.class ) != null ) {
- accessType = getAccessTypeForClass(superClass);
- if ( accessType != null ) {
- this.defaultAccessTypeForHierarchy = accessType;
- return accessType;
+ else {
+ break; //neither @Entity nor @MappedSuperclass
}
}
- else {
- break; //neither @Entity nor @MappedSuperclass
- }
}
+ while ( superClass != null );
}
- while ( superClass != null );
+
+ if ( accessType == null ) {
+ accessType = AccessType.PROPERTY; //default to property
+ this.defaultAccessTypeForElement = accessType;
+ }
//this is a subclass so caching is OK
- this.defaultAccessTypeForHierarchy = accessType;
- context.addAccessType( this.element, AccessType.PROPERTY );
- return AccessType.PROPERTY; //default to getter
+ //this.defaultAccessTypeForHierarchy = accessType;
+ context.addAccessType( this.element, accessType );
+ this.defaultAccessTypeForElement = accessType;
+ return accessType;
}
private AccessType getAccessTypeForClass(TypeElement searchedElement) {
pe.getMessager().printMessage( Diagnostic.Kind.NOTE, "check class" + searchedElement );
- AccessType accessType = context.getAccessTypes().get( searchedElement );
+ AccessType accessType = context.getAccessType( searchedElement );
+
+ if (defaultAccessTypeForHierarchy == null) {
+ this.defaultAccessTypeForHierarchy = context.getDefaultAccessTypeForHerarchy( searchedElement );
+ }
if ( accessType != null ) {
- this.defaultAccessTypeForHierarchy = accessType;
pe.getMessager().printMessage( Diagnostic.Kind.NOTE, "Found in cache" + searchedElement + ":" + accessType );
return accessType;
}
@@ -202,43 +204,55 @@
final Access accessAnn = searchedElement.getAnnotation( Access.class );
AccessType forcedAccessType = accessAnn != null ? accessAnn.value() : null;
if ( forcedAccessType != null) {
- pe.getMessager().printMessage( Diagnostic.Kind.NOTE, "access type " + searchedElement + ":" + accessType );
+ pe.getMessager().printMessage( Diagnostic.Kind.NOTE, "access type " + searchedElement + ":" + forcedAccessType );
context.addAccessType( searchedElement, forcedAccessType );
}
+
//continue nevertheless to check if we are root and if defaultAccessTypeForHierarchy
//should be overridden
+ if ( forcedAccessType == null || defaultAccessTypeForHierarchy == null) {
+ List<? extends Element> myMembers = searchedElement.getEnclosedElements();
+ for ( Element subElement : myMembers ) {
+ List<? extends AnnotationMirror> entityAnnotations =
+ pe.getElementUtils().getAllAnnotationMirrors( subElement );
- List<? extends Element> myMembers = searchedElement.getEnclosedElements();
- for ( Element subElement : myMembers ) {
- List<? extends AnnotationMirror> entityAnnotations =
- pe.getElementUtils().getAllAnnotationMirrors( subElement );
+ for ( Object entityAnnotation : entityAnnotations ) {
+ AnnotationMirror annotationMirror = ( AnnotationMirror ) entityAnnotation;
- for ( Object entityAnnotation : entityAnnotations ) {
- AnnotationMirror annotationMirror = ( AnnotationMirror ) entityAnnotation;
+ final String annotationType = annotationMirror.getAnnotationType().toString();
- final String annotationType = annotationMirror.getAnnotationType().toString();
-
- //FIXME consider XML
- if ( annotationType.equals( Id.class.getName() )
- || annotationType.equals( EmbeddedId.class.getName() ) ) {
- pe.getMessager().printMessage( Diagnostic.Kind.NOTE, "Found id on" + searchedElement );
- final ElementKind kind = subElement.getKind();
- if ( kind == ElementKind.FIELD || kind == ElementKind.METHOD ) {
- accessType = kind == ElementKind.FIELD ? AccessType.FIELD : AccessType.PROPERTY;
- this.defaultAccessTypeForHierarchy = accessType;
- if ( forcedAccessType == null) {
- context.addAccessType( searchedElement, accessType );
- pe.getMessager().printMessage( Diagnostic.Kind.NOTE, "access type " + searchedElement + ":" + accessType );
- return accessType;
+ //FIXME consider XML
+ if ( annotationType.equals( Id.class.getName() )
+ || annotationType.equals( EmbeddedId.class.getName() ) ) {
+ pe.getMessager().printMessage( Diagnostic.Kind.NOTE, "Found id on" + searchedElement );
+ final ElementKind kind = subElement.getKind();
+ if ( kind == ElementKind.FIELD || kind == ElementKind.METHOD ) {
+ accessType = kind == ElementKind.FIELD ? AccessType.FIELD : AccessType.PROPERTY;
+ //FIXME enlever in niveau
+ if (defaultAccessTypeForHierarchy == null) {
+ this.defaultAccessTypeForHierarchy = context.getDefaultAccessTypeForHerarchy( searchedElement );
+ //we've discovered the class hierarchy, let's cache it
+ if ( defaultAccessTypeForHierarchy == null ) {
+ this.defaultAccessTypeForHierarchy = accessType;
+ context.addAccessTypeForHierarchy( searchedElement, defaultAccessTypeForHierarchy );
+ //FIXME should we add
+ //context.addAccessTypeForHierarchy( element, defaultAccessTypeForHierarchy );
+ }
+ }
+ if ( forcedAccessType == null) {
+ context.addAccessType( searchedElement, accessType );
+ pe.getMessager().printMessage( Diagnostic.Kind.NOTE, "access type " + searchedElement + ":" + accessType );
+ return accessType;
+ }
+ else {
+ return forcedAccessType;
+ }
}
- else {
- return forcedAccessType;
- }
}
}
}
}
- return null;
+ return forcedAccessType;
}
@Override
@@ -312,8 +326,15 @@
if ( isPersistent( element ) ) {
TypeElement returnedElement = ( TypeElement ) pe.getTypeUtils().asElement( t );
String collection = COLLECTIONS.get( returnedElement.getQualifiedName().toString() ); // WARNING: .toString() is necessary here since Name equals does not compare to String
- //FIXME collection of element
+
if ( collection != null ) {
+ //collection of element
+ if ( element.getAnnotation( ElementCollection.class ) != null ) {
+ final TypeMirror collectionType = t.getTypeArguments().get( 0 );
+ final TypeElement collectionElement = ( TypeElement ) pe.getTypeUtils().asElement( collectionType );
+ this.parent.context.processElement( collectionElement,
+ this.parent.defaultAccessTypeForElement );
+ }
if ( collection.equals( "javax.persistence.metamodel.MapAttribute" ) ) {
return new MetaMap( parent, element, collection, getKeyType( t ), getElementType( t ) );
}
@@ -326,7 +347,7 @@
if ( element.getAnnotation( Embedded.class ) != null
|| returnedElement.getAnnotation( Embeddable.class ) != null ) {
this.parent.context.processElement( returnedElement,
- this.parent.defaultAccessTypeForHierarchy );
+ this.parent.defaultAccessTypeForElement );
}
return new MetaSingleAttribute( parent, element, returnedElement.getQualifiedName().toString() );
}
More information about the hibernate-commits
mailing list