[hibernate-commits] Hibernate SVN: r17254 - in core/trunk/entitymanager/src/main/java/org/hibernate/ejb: metamodel and 1 other directory.
hibernate-commits at lists.jboss.org
hibernate-commits at lists.jboss.org
Sun Aug 9 14:04:35 EDT 2009
Author: epbernard
Date: 2009-08-09 14:04:35 -0400 (Sun, 09 Aug 2009)
New Revision: 17254
Added:
core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/
core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/BasicTypeImpl.java
core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/EmbeddableTypeImpl.java
core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/EntityTypeDelegator.java
core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/EntityTypeImpl.java
core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/ManagedTypeImpl.java
core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/MetadataContext.java
core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/MetamodelFactory.java
core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/MetamodelImpl.java
core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/PluralAttributeImpl.java
core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/SingularAttributeImpl.java
Modified:
core/trunk/entitymanager/src/main/java/org/hibernate/ejb/Ejb3Configuration.java
core/trunk/entitymanager/src/main/java/org/hibernate/ejb/EntityManagerFactoryImpl.java
Log:
EJB-456 have the implementation of Metamodel ready minus some concepts left behind. This has NOT been tested to don't be too excited ladies
Modified: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/Ejb3Configuration.java
===================================================================
--- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/Ejb3Configuration.java 2009-08-09 12:54:15 UTC (rev 17253)
+++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/Ejb3Configuration.java 2009-08-09 18:04:35 UTC (rev 17254)
@@ -712,7 +712,8 @@
cfg.buildSessionFactory(),
transactionType,
discardOnClose,
- getSessionInterceptorClass( cfg.getProperties() )
+ getSessionInterceptorClass( cfg.getProperties() ),
+ cfg
);
}
catch (HibernateException e) {
Modified: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/EntityManagerFactoryImpl.java
===================================================================
--- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/EntityManagerFactoryImpl.java 2009-08-09 12:54:15 UTC (rev 17253)
+++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/EntityManagerFactoryImpl.java 2009-08-09 18:04:35 UTC (rev 17254)
@@ -3,6 +3,7 @@
import java.util.Map;
import java.util.Set;
+import java.util.Iterator;
import java.io.Serializable;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContextType;
@@ -12,28 +13,36 @@
import javax.persistence.spi.PersistenceUnitTransactionType;
import org.hibernate.SessionFactory;
+import org.hibernate.mapping.PersistentClass;
+import org.hibernate.cfg.Configuration;
import org.hibernate.ejb.criteria.QueryBuilderImpl;
+import org.hibernate.ejb.metamodel.MetamodelImpl;
/**
* @author Gavin King
* @author Emmanuel Bernard
*/
public class EntityManagerFactoryImpl implements HibernateEntityManagerFactory {
- private SessionFactory sessionFactory;
- private PersistenceUnitTransactionType transactionType;
- private boolean discardOnClose;
- private Class sessionInterceptorClass;
- private QueryBuilderImpl criteriaQueryBuilder;
+ private final SessionFactory sessionFactory;
+ private final PersistenceUnitTransactionType transactionType;
+ private final boolean discardOnClose;
+ private final Class sessionInterceptorClass;
+ private final QueryBuilderImpl criteriaQueryBuilder;
+ private final Metamodel metamodel;
public EntityManagerFactoryImpl(
SessionFactory sessionFactory,
PersistenceUnitTransactionType transactionType,
boolean discardOnClose,
- Class sessionInterceptorClass) {
+ Class<?> sessionInterceptorClass,
+ Configuration cfg) {
this.sessionFactory = sessionFactory;
this.transactionType = transactionType;
this.discardOnClose = discardOnClose;
this.sessionInterceptorClass = sessionInterceptorClass;
+ @SuppressWarnings( "unchecked" )
+ final Iterator<PersistentClass> classes = cfg.getClassMappings();
+ this.metamodel = new MetamodelImpl( classes );
this.criteriaQueryBuilder = new QueryBuilderImpl( this );
}
@@ -54,8 +63,7 @@
}
public Metamodel getMetamodel() {
- //FIXME
- return null; //To change body of implemented methods use File | Settings | File Templates.
+ return metamodel; //To change body of implemented methods use File | Settings | File Templates.
}
public void close() {
Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/BasicTypeImpl.java
===================================================================
--- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/BasicTypeImpl.java (rev 0)
+++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/BasicTypeImpl.java 2009-08-09 18:04:35 UTC (rev 17254)
@@ -0,0 +1,26 @@
+package org.hibernate.ejb.metamodel;
+
+import java.io.Serializable;
+import javax.persistence.metamodel.BasicType;
+import javax.persistence.metamodel.Type;
+
+/**
+ * @author Emmanuel Bernard
+ */
+public class BasicTypeImpl<X> implements BasicType<X>, Serializable {
+ private final Class<X> clazz;
+ private PersistenceType persistenceType;
+
+ public PersistenceType getPersistenceType() {
+ return persistenceType;
+ }
+
+ public Class<X> getJavaType() {
+ return clazz;
+ }
+
+ public BasicTypeImpl(Class<X> clazz, PersistenceType persistenceType) {
+ this.clazz = clazz;
+ this.persistenceType = persistenceType;
+ }
+}
Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/EmbeddableTypeImpl.java
===================================================================
--- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/EmbeddableTypeImpl.java (rev 0)
+++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/EmbeddableTypeImpl.java 2009-08-09 18:04:35 UTC (rev 17254)
@@ -0,0 +1,21 @@
+package org.hibernate.ejb.metamodel;
+
+import java.util.Iterator;
+import java.io.Serializable;
+import javax.persistence.metamodel.EmbeddableType;
+import javax.persistence.metamodel.Type;
+
+import org.hibernate.mapping.Property;
+
+/**
+ * @author Emmanuel Bernard
+ */
+public class EmbeddableTypeImpl<X> extends ManagedTypeImpl<X> implements EmbeddableType<X>, Serializable {
+ EmbeddableTypeImpl(Class<X> clazz, Iterator<Property> properties, MetadataContext context) {
+ super(clazz, properties, context);
+ }
+
+ public PersistenceType getPersistenceType() {
+ return PersistenceType.EMBEDDABLE;
+ }
+}
Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/EntityTypeDelegator.java
===================================================================
--- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/EntityTypeDelegator.java (rev 0)
+++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/EntityTypeDelegator.java 2009-08-09 18:04:35 UTC (rev 17254)
@@ -0,0 +1,196 @@
+package org.hibernate.ejb.metamodel;
+
+import java.util.Set;
+import java.io.Serializable;
+import javax.persistence.metamodel.Attribute;
+import javax.persistence.metamodel.CollectionAttribute;
+import javax.persistence.metamodel.EntityType;
+import javax.persistence.metamodel.IdentifiableType;
+import javax.persistence.metamodel.ListAttribute;
+import javax.persistence.metamodel.MapAttribute;
+import javax.persistence.metamodel.PluralAttribute;
+import javax.persistence.metamodel.SetAttribute;
+import javax.persistence.metamodel.SingularAttribute;
+import javax.persistence.metamodel.Type;
+
+/**
+ * Delegate to an other EntityType<X>
+ * Helps break infinite loops when creating entity metamodel related to each other
+ *
+ * @author Emmanuel Bernard
+ */
+public class EntityTypeDelegator<X> implements EntityType<X>, Serializable {
+ private volatile EntityType<X> delegate;
+
+ void setDelegate(EntityType<X> delegate) {
+ this.delegate = delegate;
+ }
+
+ public String getName() {
+ return delegate.getName();
+ }
+
+ public <Y> SingularAttribute<? super X, Y> getId(Class<Y> type) {
+ return delegate.getId( type );
+ }
+
+ public <Y> SingularAttribute<? super X, Y> getVersion(Class<Y> type) {
+ return delegate.getVersion( type );
+ }
+
+ public <Y> SingularAttribute<X, Y> getDeclaredId(Class<Y> type) {
+ return delegate.getDeclaredId( type );
+ }
+
+ public <Y> SingularAttribute<X, Y> getDeclaredVersion(Class<Y> type) {
+ return delegate.getDeclaredVersion( type );
+ }
+
+ public IdentifiableType<? super X> getSupertype() {
+ return delegate.getSupertype();
+ }
+
+ public boolean hasSingleIdAttribute() {
+ return delegate.hasSingleIdAttribute();
+ }
+
+ public boolean hasVersionAttribute() {
+ return delegate.hasVersionAttribute();
+ }
+
+ public Set<SingularAttribute<? super X, ?>> getIdClassAttributes() {
+ return delegate.getIdClassAttributes();
+ }
+
+ public Type<?> getIdType() {
+ return delegate.getIdType();
+ }
+
+ public Set<Attribute<? super X, ?>> getAttributes() {
+ return delegate.getAttributes();
+ }
+
+ public Set<Attribute<X, ?>> getDeclaredAttributes() {
+ return delegate.getDeclaredAttributes();
+ }
+
+ public <Y> SingularAttribute<? super X, Y> getSingularAttribute(String name, Class<Y> type) {
+ return delegate.getSingularAttribute( name, type );
+ }
+
+ public <Y> SingularAttribute<X, Y> getDeclaredSingularAttribute(String name, Class<Y> type) {
+ return delegate.getDeclaredSingularAttribute( name, type );
+ }
+
+ public Set<SingularAttribute<? super X, ?>> getSingularAttributes() {
+ return delegate.getSingularAttributes();
+ }
+
+ public Set<SingularAttribute<X, ?>> getDeclaredSingularAttributes() {
+ return delegate.getDeclaredSingularAttributes();
+ }
+
+ public <E> CollectionAttribute<? super X, E> getCollection(String name, Class<E> elementType) {
+ return delegate.getCollection( name, elementType );
+ }
+
+ public <E> SetAttribute<? super X, E> getSet(String name, Class<E> elementType) {
+ return delegate.getSet( name, elementType );
+ }
+
+ public <E> ListAttribute<? super X, E> getList(String name, Class<E> elementType) {
+ return delegate.getList( name, elementType );
+ }
+
+ public <K, V> MapAttribute<? super X, K, V> getMap(String name, Class<K> keyType, Class<V> valueType) {
+ return delegate.getMap( name, keyType, valueType );
+ }
+
+ public <E> CollectionAttribute<X, E> getDeclaredCollection(String name, Class<E> elementType) {
+ return delegate.getDeclaredCollection( name, elementType );
+ }
+
+ public <E> SetAttribute<X, E> getDeclaredSet(String name, Class<E> elementType) {
+ return delegate.getDeclaredSet( name, elementType );
+ }
+
+ public <E> ListAttribute<X, E> getDeclaredList(String name, Class<E> elementType) {
+ return delegate.getDeclaredList( name, elementType );
+ }
+
+ public <K, V> MapAttribute<X, K, V> getDeclaredMap(String name, Class<K> keyType, Class<V> valueType) {
+ return delegate.getDeclaredMap( name, keyType, valueType );
+ }
+
+ public Set<PluralAttribute<? super X, ?, ?>> getCollections() {
+ return delegate.getCollections();
+ }
+
+ public Set<PluralAttribute<X, ?, ?>> getDeclaredCollections() {
+ return delegate.getDeclaredCollections();
+ }
+
+ public Attribute<? super X, ?> getAttribute(String name) {
+ return delegate.getAttribute( name );
+ }
+
+ public Attribute<X, ?> getDeclaredAttribute(String name) {
+ return delegate.getDeclaredAttribute( name );
+ }
+
+ public SingularAttribute<? super X, ?> getSingularAttribute(String name) {
+ return delegate.getSingularAttribute( name );
+ }
+
+ public SingularAttribute<X, ?> getDeclaredSingularAttribute(String name) {
+ return delegate.getDeclaredSingularAttribute( name );
+ }
+
+ public CollectionAttribute<? super X, ?> getCollection(String name) {
+ return delegate.getCollection( name );
+ }
+
+ public SetAttribute<? super X, ?> getSet(String name) {
+ return delegate.getSet( name );
+ }
+
+ public ListAttribute<? super X, ?> getList(String name) {
+ return delegate.getList( name );
+ }
+
+ public MapAttribute<? super X, ?, ?> getMap(String name) {
+ return delegate.getMap( name );
+ }
+
+ public CollectionAttribute<X, ?> getDeclaredCollection(String name) {
+ return delegate.getDeclaredCollection( name );
+ }
+
+ public SetAttribute<X, ?> getDeclaredSet(String name) {
+ return delegate.getDeclaredSet( name );
+ }
+
+ public ListAttribute<X, ?> getDeclaredList(String name) {
+ return delegate.getDeclaredList( name );
+ }
+
+ public MapAttribute<X, ?, ?> getDeclaredMap(String name) {
+ return delegate.getDeclaredMap( name );
+ }
+
+ public PersistenceType getPersistenceType() {
+ return delegate.getPersistenceType();
+ }
+
+ public Class<X> getJavaType() {
+ return delegate.getJavaType();
+ }
+
+ public BindableType getBindableType() {
+ return delegate.getBindableType();
+ }
+
+ public Class<X> getBindableJavaType() {
+ return delegate.getBindableJavaType();
+ }
+}
Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/EntityTypeImpl.java
===================================================================
--- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/EntityTypeImpl.java (rev 0)
+++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/EntityTypeImpl.java 2009-08-09 18:04:35 UTC (rev 17254)
@@ -0,0 +1,164 @@
+package org.hibernate.ejb.metamodel;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+import java.io.Serializable;
+import javax.persistence.metamodel.EntityType;
+import javax.persistence.metamodel.IdentifiableType;
+import javax.persistence.metamodel.SingularAttribute;
+import javax.persistence.metamodel.Type;
+
+import org.hibernate.mapping.PersistentClass;
+import org.hibernate.mapping.Property;
+
+/**
+ * @author Emmanuel Bernard
+ */
+public class EntityTypeImpl<X> extends ManagedTypeImpl<X> implements EntityType<X>, Serializable {
+
+ private final SingularAttribute<X, ?> id;
+ private final SingularAttribute<X, ?> version;
+ private final String className;
+ private final boolean hasIdentifierProperty;
+ private final boolean isVersioned;
+ private final Set<SingularAttribute<? super X,?>> idClassAttributes;
+ private final IdentifiableType<? super X> supertype;
+
+ public EntityTypeImpl(Class<X> clazz, PersistentClass persistentClass, MetadataContext context) {
+ super(clazz, (Iterator<Property>) persistentClass.getPropertyIterator(), context );
+ this.className = persistentClass.getClassName();
+ this.hasIdentifierProperty = persistentClass.hasIdentifierProperty();
+ this.isVersioned = persistentClass.isVersioned();
+ id = buildIdAttribute( persistentClass );
+ version = buildVersionAttribute( persistentClass );
+ final Set<SingularAttribute<? super X, ?>> attributes = buildIdClassAttributes( persistentClass, context );
+ this.idClassAttributes = attributes != null ? Collections.unmodifiableSet( attributes ) : null;
+
+ PersistentClass superPersistentClass = persistentClass.getSuperclass();
+ if ( superPersistentClass == null ) {
+ supertype = null;
+ }
+ else {
+ final Class<?> superclass = superPersistentClass.getMappedClass();
+ final EntityTypeDelegator<X> entityTypeDelegator = new EntityTypeDelegator<X>();
+ context.addDelegator( entityTypeDelegator, superclass );
+ supertype = entityTypeDelegator;
+ }
+ }
+
+ private <A> SingularAttribute<X, A> buildIdAttribute(PersistentClass persistentClass) {
+ final Property identifierProperty = persistentClass.getIdentifierProperty();
+ @SuppressWarnings( "unchecked" )
+ Class<A> idClass = identifierProperty.getType().getReturnedClass();
+ final Type<A> attrType = new BasicTypeImpl<A>( idClass,
+ identifierProperty.isComposite() ?
+ PersistenceType.EMBEDDABLE :
+ PersistenceType.BASIC);
+ return SingularAttributeImpl.create(this, attrType )
+ .property(identifierProperty)
+ //.member( null ) //TODO member
+ .id()
+ .build();
+ }
+
+ private <A> SingularAttribute<X, A> buildVersionAttribute(PersistentClass persistentClass) {
+ if ( persistentClass.isVersioned() ) {
+ @SuppressWarnings( "unchecked" )
+ Class<A> versionClass = persistentClass.getVersion().getType().getReturnedClass();
+ Property property = persistentClass.getVersion();
+ final Type<A> attrType = new BasicTypeImpl<A>( versionClass, PersistenceType.BASIC);
+ return SingularAttributeImpl.create(this, attrType )
+ .property(property)
+ //.member( null ) //TODO member
+ .version()
+ .build();
+ }
+ else {
+ return null;
+ }
+ }
+
+ private Set<SingularAttribute<? super X, ?>> buildIdClassAttributes(PersistentClass persistentClass, MetadataContext context) {
+ if ( hasSingleIdAttribute() ) {
+ return null;
+ }
+ @SuppressWarnings( "unchecked")
+ Iterator<Property> properties = persistentClass.getIdentifierMapper().getPropertyIterator();
+ Set<SingularAttribute<? super X, ?>> attributes = new HashSet<SingularAttribute<? super X, ?>>();
+ while ( properties.hasNext() ) {
+ attributes.add(
+ (SingularAttribute<? super X, ?>) MetamodelFactory.getAttribute( this, properties.next(), context )
+ );
+ }
+ return attributes;
+ }
+
+ public String getName() {
+ return className;
+ }
+
+ public <Y> SingularAttribute<? super X, Y> getId(Class<Y> type) {
+ //TODO check that type and id.getJavaType() are related
+ @SuppressWarnings( "unchecked")
+ final SingularAttribute<? super X, Y> result = ( SingularAttribute<? super X, Y> ) id;
+ return result;
+ }
+
+ public <Y> SingularAttribute<? super X, Y> getVersion(Class<Y> type) {
+ //TODO check that type and version.getJavaType() are related
+ @SuppressWarnings( "unchecked")
+ final SingularAttribute<? super X, Y> result = ( SingularAttribute<? super X, Y> ) version;
+ return result;
+ }
+
+ public <Y> SingularAttribute<X, Y> getDeclaredId(Class<Y> type) {
+ //TODO check that type and id.getJavaType() are related
+ @SuppressWarnings("unchecked")
+ final SingularAttribute<X, Y> result = ( SingularAttribute<X, Y> ) id;
+ return result;
+ }
+
+ public <Y> SingularAttribute<X, Y> getDeclaredVersion(Class<Y> type) {
+ //TODO check that type and version.getJavaType() are related
+ @SuppressWarnings("unchecked")
+ final SingularAttribute<X, Y> result = ( SingularAttribute<X, Y> ) version;
+ return result;
+ }
+
+ public IdentifiableType<? super X> getSupertype() {
+ return supertype;
+ }
+
+ public boolean hasSingleIdAttribute() {
+ return hasIdentifierProperty;
+ }
+
+ public boolean hasVersionAttribute() {
+ return isVersioned;
+ }
+
+ public Set<SingularAttribute<? super X, ?>> getIdClassAttributes() {
+ if ( hasSingleIdAttribute() ) {
+ throw new IllegalArgumentException( "This class does not use @IdClass: " + getName() );
+ }
+ return idClassAttributes;
+ }
+
+ public Type<?> getIdType() {
+ return id.getType();
+ }
+
+ public BindableType getBindableType() {
+ return BindableType.ENTITY_TYPE;
+ }
+
+ public Class<X> getBindableJavaType() {
+ return getJavaType();
+ }
+
+ public PersistenceType getPersistenceType() {
+ return PersistenceType.ENTITY;
+ }
+}
Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/ManagedTypeImpl.java
===================================================================
--- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/ManagedTypeImpl.java (rev 0)
+++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/ManagedTypeImpl.java 2009-08-09 18:04:35 UTC (rev 17254)
@@ -0,0 +1,284 @@
+package org.hibernate.ejb.metamodel;
+
+import java.util.Iterator;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.Collections;
+import java.util.Map;
+import java.util.HashMap;
+
+import javax.persistence.metamodel.ManagedType;
+import javax.persistence.metamodel.Attribute;
+import javax.persistence.metamodel.SingularAttribute;
+import javax.persistence.metamodel.CollectionAttribute;
+import javax.persistence.metamodel.SetAttribute;
+import javax.persistence.metamodel.ListAttribute;
+import javax.persistence.metamodel.MapAttribute;
+import javax.persistence.metamodel.PluralAttribute;
+import javax.persistence.metamodel.Bindable;
+
+import org.hibernate.mapping.Property;
+import org.hibernate.annotations.common.AssertionFailure;
+
+/**
+ * @author Emmanuel Bernard
+ */
+public abstract class ManagedTypeImpl<X> implements ManagedType<X> {
+ private final Class<X> javaClass;
+ private final Map<String,Attribute<X, ?>> declaredAttributes;
+ private final Map<String,SingularAttribute<X, ?>> declaredSingularAttributes;
+ private final Map<String,PluralAttribute<X, ?, ?>> declaredCollections;
+
+
+ ManagedTypeImpl(Class<X> clazz, Iterator<Property> properties, MetadataContext context) {
+ this.javaClass = clazz;
+ Map<String,Attribute<X, ?>> localDeclAttr = new HashMap<String,Attribute<X, ?>>();
+ Map<String,SingularAttribute<X, ?>> localDeclSingAttr = new HashMap<String,SingularAttribute<X, ?>>();
+ Map<String,PluralAttribute<X,?,?>> localDeclPlurAttr = new HashMap<String,PluralAttribute<X,?,?>>();
+
+ while ( properties.hasNext() ) {
+ Property property = properties.next();
+ addProperty( property, context, localDeclAttr, localDeclSingAttr, localDeclPlurAttr );
+ }
+ declaredAttributes = Collections.unmodifiableMap( localDeclAttr );
+ declaredSingularAttributes = Collections.unmodifiableMap( localDeclSingAttr );
+ declaredCollections = Collections.unmodifiableMap( localDeclPlurAttr );
+ }
+
+ private <T> void addProperty(Property property,
+ MetadataContext context,
+ Map<String,Attribute<X, ?>> localDeclAttr,
+ Map<String,SingularAttribute<X, ?>> localDeclSingAttr,
+ Map<String,PluralAttribute<X,?,?>> localDeclPlurAttr) {
+ final Attribute<X, ?> attribute = MetamodelFactory.getAttribute( this, property, context );
+ localDeclAttr.put(attribute.getName(), attribute );
+ final Bindable.BindableType bindableType = ( ( Bindable<T> ) attribute ).getBindableType();
+ switch ( bindableType ) {
+ case SINGULAR_ATTRIBUTE:
+ localDeclSingAttr.put(attribute.getName(), (SingularAttribute<X, ?>) attribute );
+ break;
+ case PLURAL_ATTRIBUTE:
+ localDeclPlurAttr.put(attribute.getName(), (PluralAttribute<X,?,?>) attribute );
+ break;
+ default:
+ throw new AssertionFailure( "unknown bindable type: " + bindableType );
+ }
+
+ }
+
+ public Set<Attribute<? super X, ?>> getAttributes() {
+ return null; //To change body of implemented methods use File | Settings | File Templates.
+ }
+
+ public Set<Attribute<X, ?>> getDeclaredAttributes() {
+ return new HashSet<Attribute<X, ?>>(declaredAttributes.values());
+ }
+
+ public <Y> SingularAttribute<? super X, Y> getSingularAttribute(String name, Class<Y> type) {
+ return null; //To change body of implemented methods use File | Settings | File Templates.
+ }
+
+ public <Y> SingularAttribute<X, Y> getDeclaredSingularAttribute(String name, Class<Y> type) {
+ final SingularAttribute<X, ?> attr = declaredSingularAttributes.get( name );
+ checkTypeForSingleAttribute( "SingularAttribute ", attr, name, type );
+ @SuppressWarnings( "unchecked")
+ final SingularAttribute<X, Y> result = ( SingularAttribute<X, Y> ) attr;
+ return result;
+ }
+
+ private <Y> void checkTypeForSingleAttribute(String error, SingularAttribute<?,?> attr, String name, Class<Y> type) {
+ if (attr == null || ( type != null && !attr.getBindableJavaType().equals( type ) ) ) {
+ throw new IllegalArgumentException(
+ error + " named " + name
+ + (type != null ? " and of type " + type : "")
+ + " is not present");
+ }
+ }
+
+ private <Y> void checkTypeForPluralAttributes(String error,
+ PluralAttribute<?,?,?> attr,
+ String name,
+ Class<Y> type,
+ PluralAttribute.CollectionType collectionType) {
+ if (attr == null
+ || ( type != null && !attr.getBindableJavaType().equals( type ) )
+ || attr.getCollectionType() != collectionType ) {
+ throw new IllegalArgumentException(
+ error + " named " + name
+ + (type != null ? " and of element type " + type : "")
+ + " is not present");
+ }
+ }
+
+ private <Y> void checkNotNull(String error, Attribute<?,?> attr, String name) {
+ if (attr == null) {
+ throw new IllegalArgumentException(
+ error + " named " + name
+ + " is not present");
+ }
+ }
+
+ public Set<SingularAttribute<? super X, ?>> getSingularAttributes() {
+ return null; //To change body of implemented methods use File | Settings | File Templates.
+ }
+
+ public Set<SingularAttribute<X, ?>> getDeclaredSingularAttributes() {
+ return new HashSet<SingularAttribute<X, ?>>(declaredSingularAttributes.values());
+ }
+
+ public <E> CollectionAttribute<? super X, E> getCollection(String name, Class<E> elementType) {
+ return null; //To change body of implemented methods use File | Settings | File Templates.
+ }
+
+ public <E> SetAttribute<? super X, E> getSet(String name, Class<E> elementType) {
+ return null; //To change body of implemented methods use File | Settings | File Templates.
+ }
+
+ public <E> ListAttribute<? super X, E> getList(String name, Class<E> elementType) {
+ return null; //To change body of implemented methods use File | Settings | File Templates.
+ }
+
+ public <K, V> MapAttribute<? super X, K, V> getMap(String name, Class<K> keyType, Class<V> valueType) {
+ return null; //To change body of implemented methods use File | Settings | File Templates.
+ }
+
+ public <E> CollectionAttribute<X, E> getDeclaredCollection(String name, Class<E> elementType) {
+ final PluralAttribute<X,?,?> attr = declaredCollections.get( name );
+ checkTypeForPluralAttributes( "CollectionAttribute ", attr, name, elementType, PluralAttribute.CollectionType.COLLECTION );
+ @SuppressWarnings( "unchecked")
+ final CollectionAttribute<X, E> result = ( CollectionAttribute<X, E> ) attr;
+ return result;
+ }
+
+ public <E> SetAttribute<X, E> getDeclaredSet(String name, Class<E> elementType) {
+ final PluralAttribute<X,?,?> attr = declaredCollections.get( name );
+ checkTypeForPluralAttributes( "SetAttribute ", attr, name, elementType, PluralAttribute.CollectionType.SET );
+ @SuppressWarnings( "unchecked")
+ final SetAttribute<X, E> result = ( SetAttribute<X, E> ) attr;
+ return result;
+ }
+
+ public <E> ListAttribute<X, E> getDeclaredList(String name, Class<E> elementType) {
+ final PluralAttribute<X,?,?> attr = declaredCollections.get( name );
+ checkTypeForPluralAttributes( "ListAttribute ", attr, name, elementType, PluralAttribute.CollectionType.LIST );
+ @SuppressWarnings( "unchecked")
+ final ListAttribute<X, E> result = ( ListAttribute<X, E> ) attr;
+ return result;
+ }
+
+ public <K, V> MapAttribute<X, K, V> getDeclaredMap(String name, Class<K> keyType, Class<V> valueType) {
+ final PluralAttribute<X,?,?> attr = declaredCollections.get( name );
+ final String error = "MapAttribute ";
+ checkTypeForPluralAttributes( error, attr, name, valueType, PluralAttribute.CollectionType.LIST );
+ @SuppressWarnings( "unchecked")
+ final MapAttribute<X, K, V> result = ( MapAttribute<X, K, V> ) attr;
+ if ( result.getKeyJavaType() != keyType ) {
+ throw new IllegalArgumentException(
+ error + " named " + name + " does not support a key of type " + keyType
+ );
+ }
+ return result;
+ }
+
+ public Set<PluralAttribute<? super X, ?, ?>> getCollections() {
+ return null; //To change body of implemented methods use File | Settings | File Templates.
+ }
+
+ public Set<PluralAttribute<X, ?, ?>> getDeclaredCollections() {
+ return new HashSet<PluralAttribute<X,?,?>>(declaredCollections.values());
+ }
+
+ public Attribute<? super X, ?> getAttribute(String name) {
+ return null; //To change body of implemented methods use File | Settings | File Templates.
+ }
+
+ public Attribute<X, ?> getDeclaredAttribute(String name) {
+ final Attribute<X, ?> attr = declaredSingularAttributes.get( name );
+ checkNotNull( "Attribute ", attr, name );
+ return attr;
+ }
+
+ public SingularAttribute<? super X, ?> getSingularAttribute(String name) {
+ return null; //To change body of implemented methods use File | Settings | File Templates.
+ }
+
+ public SingularAttribute<X, ?> getDeclaredSingularAttribute(String name) {
+ final SingularAttribute<X, ?> attr = declaredSingularAttributes.get( name );
+ checkNotNull( "SingularAttribute ", attr, name );
+ return attr;
+ }
+
+ public CollectionAttribute<? super X, ?> getCollection(String name) {
+ return null; //To change body of implemented methods use File | Settings | File Templates.
+ }
+
+ public SetAttribute<? super X, ?> getSet(String name) {
+ return null; //To change body of implemented methods use File | Settings | File Templates.
+ }
+
+ public ListAttribute<? super X, ?> getList(String name) {
+ return null; //To change body of implemented methods use File | Settings | File Templates.
+ }
+
+ public MapAttribute<? super X, ?, ?> getMap(String name) {
+ return null; //To change body of implemented methods use File | Settings | File Templates.
+ }
+
+ public CollectionAttribute<X, ?> getDeclaredCollection(String name) {
+ final PluralAttribute<X,?,?> attr = declaredCollections.get( name );
+ final String error = "CollectionAttribute ";
+ checkNotNull( error, attr, name );
+ if ( ! CollectionAttribute.class.isAssignableFrom( attr.getClass() ) ) {
+ throw new IllegalArgumentException( name
+ + " is not a " + error + ": " + attr.getClass() );
+ }
+ @SuppressWarnings( "unchecked")
+ final CollectionAttribute<X, ?> result = ( CollectionAttribute<X, ?> ) attr;
+ return result;
+ }
+
+ public SetAttribute<X, ?> getDeclaredSet(String name) {
+ final PluralAttribute<X,?,?> attr = declaredCollections.get( name );
+ final String error = "SetAttribute ";
+ checkNotNull( error, attr, name );
+ if ( ! CollectionAttribute.class.isAssignableFrom( attr.getClass() ) ) {
+ throw new IllegalArgumentException( name
+ + " is not a " + error + ": " + attr.getClass() );
+ }
+ @SuppressWarnings( "unchecked")
+ final SetAttribute<X, ?> result = ( SetAttribute<X, ?> ) attr;
+ return result;
+ }
+
+ public ListAttribute<X, ?> getDeclaredList(String name) {
+ final PluralAttribute<X,?,?> attr = declaredCollections.get( name );
+ final String error = "ListAttribute ";
+ checkNotNull( error, attr, name );
+ if ( ! CollectionAttribute.class.isAssignableFrom( attr.getClass() ) ) {
+ throw new IllegalArgumentException( name
+ + " is not a " + error + ": " + attr.getClass() );
+ }
+ @SuppressWarnings( "unchecked")
+ final ListAttribute<X, ?> result = ( ListAttribute<X, ?> ) attr;
+ return result;
+ }
+
+ public MapAttribute<X, ?, ?> getDeclaredMap(String name) {
+ final PluralAttribute<X,?,?> attr = declaredCollections.get( name );
+ final String error = "MapAttribute ";
+ checkNotNull( error, attr, name );
+ if ( ! MapAttribute.class.isAssignableFrom( attr.getClass() ) ) {
+ throw new IllegalArgumentException( name
+ + " is not a " + error + ": " + attr.getClass() );
+ }
+ @SuppressWarnings( "unchecked")
+ final MapAttribute<X,?,?> result = ( MapAttribute<X,?,?> ) attr;
+ return result;
+ }
+
+ public abstract PersistenceType getPersistenceType();
+
+ public Class<X> getJavaType() {
+ return javaClass;
+ }
+}
Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/MetadataContext.java
===================================================================
--- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/MetadataContext.java (rev 0)
+++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/MetadataContext.java 2009-08-09 18:04:35 UTC (rev 17254)
@@ -0,0 +1,42 @@
+package org.hibernate.ejb.metamodel;
+
+import java.util.HashMap;
+import java.util.Map;
+import javax.persistence.metamodel.Metamodel;
+import javax.persistence.metamodel.EmbeddableType;
+
+/**
+ * Keep contextual information related tot he metedata building process.
+ * In particular keeps data than theens to be processed in a second phase.
+ * @author Emmanuel Bernard
+ */
+class MetadataContext {
+ private Map<EntityTypeDelegator<?>, Class<?>> delegators = new HashMap<EntityTypeDelegator<?>, Class<?>>();
+ private Map<Class<?>, EmbeddableType<?>> embeddables = new HashMap<Class<?>, EmbeddableType<?>>();
+
+ void addDelegator(EntityTypeDelegator<?> type, Class<?> clazz) {
+ delegators.put(type, clazz);
+ }
+
+ void postProcess(Metamodel model) {
+ for ( Map.Entry<EntityTypeDelegator<?>, Class<?>> entry : delegators.entrySet() ) {
+ setDelegate( model, entry );
+ }
+ }
+
+ private <X> void setDelegate(Metamodel model, Map.Entry<EntityTypeDelegator<?>, Class<?>> entry) {
+ @SuppressWarnings( "unchecked" )
+ final Class<X> entityClass = (Class<X>) entry.getValue();
+ @SuppressWarnings( "unchecked" )
+ final EntityTypeDelegator<X> delegator = (EntityTypeDelegator<X>) entry.getKey();
+ delegator.setDelegate( model.entity( entityClass ) );
+ }
+
+ <X> void addEmbeddableType(Class<X> clazz, EmbeddableType<X> embeddableType) {
+ embeddables.put( clazz, embeddableType );
+ }
+
+ Map<Class<?>, EmbeddableType<?>> getEmbeddableTypes() {
+ return embeddables;
+ }
+}
Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/MetamodelFactory.java
===================================================================
--- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/MetamodelFactory.java (rev 0)
+++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/MetamodelFactory.java 2009-08-09 18:04:35 UTC (rev 17254)
@@ -0,0 +1,323 @@
+package org.hibernate.ejb.metamodel;
+
+import java.util.Iterator;
+import javax.persistence.metamodel.Attribute;
+import javax.persistence.metamodel.ManagedType;
+import javax.persistence.metamodel.Type;
+import javax.persistence.metamodel.EmbeddableType;
+
+import org.hibernate.annotations.common.AssertionFailure;
+import org.hibernate.mapping.Collection;
+import org.hibernate.mapping.Component;
+import org.hibernate.mapping.Map;
+import org.hibernate.mapping.OneToMany;
+import org.hibernate.mapping.Property;
+import org.hibernate.mapping.Value;
+
+/**
+ * @author Emmanuel Bernard
+ */
+class MetamodelFactory {
+
+ static<X, Y, V, K> Attribute<X, Y> getAttribute(ManagedType<X> ownerType, Property property, MetadataContext metadataContext) {
+ AttributeContext attrContext = getAttributeContext( property );
+ final Attribute<X, Y> attribute;
+ if ( attrContext.isCollection() ) {
+ final Type<V> attrType = getType( attrContext.getElementTypeStatus(), attrContext.getElementValue(), metadataContext );
+ @SuppressWarnings( "unchecked" )
+ final Class<Y> collectionClass = (Class<Y>) attrContext.getCollectionClass();
+ if ( java.util.Map.class.isAssignableFrom( collectionClass ) ) {
+ final Type<K> keyType = getType( attrContext.getKeyTypeStatus(), attrContext.getKeyValue(), metadataContext );
+ attribute = PluralAttributeImpl.create( ownerType, attrType, collectionClass, keyType )
+ // .member( ); //TODO member
+ .property( property )
+ .persistentAttributeType( attrContext.getElementAttributeType() )
+ .build();
+ }
+ else {
+ attribute = PluralAttributeImpl.create( ownerType, attrType, collectionClass, null )
+ // .member( ); //TODO member
+ .property( property )
+ .persistentAttributeType( attrContext.getElementAttributeType() )
+ .build();
+ }
+ }
+ else {
+ final Type<Y> attrType = getType( attrContext.getElementTypeStatus(), attrContext.getElementValue(), metadataContext );
+ attribute = SingularAttributeImpl.create( ownerType, attrType )
+ // .member( ); //TODO member
+ .property( property )
+ .persistentAttributeType( attrContext.getElementAttributeType() )
+ .build();
+ }
+ return attribute;
+ }
+
+ private static <X> Type<X> getType(AttributeContext.TypeStatus elementTypeStatus, Value value, MetadataContext metadataContext) {
+ final org.hibernate.type.Type type = value.getType();
+ switch ( elementTypeStatus ) {
+ case BASIC:
+ return buildBasicType( type );
+ case EMBEDDABLE:
+ return buildEmbeddableType( value, type, metadataContext );
+ case ENTITY:
+ return buildEntityType( type, metadataContext );
+ default:
+ throw new AssertionFailure( "Unknown AttributeContext.TypeStatus: " + elementTypeStatus );
+
+ }
+ }
+
+ private static class AttributeContext {
+ private final Value elementValue;
+ private final TypeStatus typeStatus;
+ private final Class<?> collectionClass;
+ private final Attribute.PersistentAttributeType attrType;
+ private final Value keyValue;
+ private final TypeStatus keyTypeStatus;
+
+ enum TypeStatus {
+ EMBEDDABLE,
+ ENTITY,
+ BASIC
+ }
+
+ AttributeContext(Value elementValue,
+ TypeStatus elementTypeStatus,
+ Attribute.PersistentAttributeType elementPAT,
+ Class<?> collectionClass,
+ Value keyValue,
+ TypeStatus keyTypeStatus) {
+ this.elementValue = elementValue;
+ this.typeStatus = elementTypeStatus;
+ this.collectionClass = collectionClass;
+ this.attrType = elementPAT;
+ this.keyValue = keyValue;
+ this.keyTypeStatus = keyTypeStatus;
+ }
+
+ public Value getElementValue() {
+ return elementValue;
+ }
+
+ public TypeStatus getElementTypeStatus() {
+ return typeStatus;
+ }
+
+ public boolean isCollection() {
+ return collectionClass != null;
+ }
+
+ public Class<?> getCollectionClass() {
+ return collectionClass;
+ }
+
+ public Attribute.PersistentAttributeType getElementAttributeType() {
+ return attrType;
+ }
+
+ public Value getKeyValue() {
+ return keyValue;
+ }
+
+ public TypeStatus getKeyTypeStatus() {
+ return keyTypeStatus;
+ }
+ }
+
+
+ //FIXME the logical level for *To* is different from the Hibernate physical model.
+ //ie a @ManyToOne @AssocTable is a many-to-many for hibernate
+ //and a @OneToMany @AssocTable is a many-to-many for hibernate
+ //FIXME so basically Attribute.PersistentAttributeType is crap at the moment
+ private static AttributeContext getAttributeContext(Property property) {
+ final Value value = property.getValue();
+ org.hibernate.type.Type type = value.getType();
+ if ( type.isAnyType() ) {
+ throw new UnsupportedOperationException( "any not supported yet" );
+ }
+ else if ( type.isAssociationType() ) {
+ //collection or entity
+ if ( type.isCollectionType() ) {
+ //do collection
+ if ( value instanceof Collection ) {
+ final Collection collValue = (Collection) value;
+ final Value elementValue = collValue.getElement();
+ final org.hibernate.type.Type elementType = elementValue.getType();
+ final AttributeContext.TypeStatus elementTypeStatus;
+ final Attribute.PersistentAttributeType elementPAT;
+ final Class<?> collectionClass = collValue.getCollectionType().getReturnedClass();
+
+
+ final Value keyValue;
+ final org.hibernate.type.Type keyType;
+ final AttributeContext.TypeStatus keyTypeStatus;
+ if ( value instanceof Map ) {
+ keyValue = ( (Map) value).getIndex();
+ keyType = keyValue.getType();
+ if ( keyValue instanceof Component ) {
+ keyTypeStatus = AttributeContext.TypeStatus.EMBEDDABLE;
+ }
+ else if ( keyType.isAnyType() ) {
+ throw new UnsupportedOperationException( "collection of any not supported yet" );
+ }
+ else if ( keyType.isAssociationType() ) {
+ keyTypeStatus = AttributeContext.TypeStatus.ENTITY;
+ }
+ else {
+ keyTypeStatus = AttributeContext.TypeStatus.BASIC;
+ }
+ }
+ else {
+ keyValue = null;
+ keyTypeStatus = null;
+ }
+
+ if ( elementValue instanceof Component ) {
+ //collection of components
+ elementTypeStatus = AttributeContext.TypeStatus.EMBEDDABLE;
+ elementPAT = Attribute.PersistentAttributeType.ELEMENT_COLLECTION;
+ }
+ else if ( elementType.isAnyType() ) {
+ throw new UnsupportedOperationException( "collection of any not supported yet" );
+ }
+ else if ( elementType.isAssociationType() ) {
+ //collection of entity
+ elementTypeStatus = AttributeContext.TypeStatus.ENTITY;
+ elementPAT = Attribute.PersistentAttributeType.MANY_TO_MANY;
+ }
+ else {
+ //collection of basic type
+ elementTypeStatus = AttributeContext.TypeStatus.BASIC;
+ elementPAT = Attribute.PersistentAttributeType.ELEMENT_COLLECTION;
+ }
+ return new AttributeContext(
+ elementValue,
+ elementTypeStatus,
+ elementPAT,
+ collectionClass,
+ keyValue,
+ keyTypeStatus
+ );
+ }
+ else if ( value instanceof OneToMany ) {
+ //one to many with FK => entity
+ return new AttributeContext(
+ value,
+ AttributeContext.TypeStatus.ENTITY,
+ Attribute.PersistentAttributeType.ONE_TO_MANY,
+ null, null, null );
+ }
+
+ }
+ else {
+ //ToOne association
+ return new AttributeContext(
+ value,
+ AttributeContext.TypeStatus.ENTITY,
+ Attribute.PersistentAttributeType.MANY_TO_MANY, //FIXME how to differentiate the logical many to one from the one to one (not physical level)
+ null, null, null);
+ }
+ }
+ else if ( property.isComposite() ) {
+ //embeddable
+ return new AttributeContext(
+ value,
+ AttributeContext.TypeStatus.EMBEDDABLE,
+ Attribute.PersistentAttributeType.EMBEDDED,
+ null, null, null);
+
+ }
+ else {
+ //basic type
+ return new AttributeContext(
+ value,
+ AttributeContext.TypeStatus.BASIC,
+ Attribute.PersistentAttributeType.BASIC,
+ null, null, null);
+ }
+ throw new UnsupportedOperationException("oops, we are missing something: " + property.toString() );
+ }
+
+
+
+ static <X> Type<X> getType(Property property, MetadataContext context) {
+ final Value value = property.getValue();
+ org.hibernate.type.Type type = value.getType();
+ if ( type.isAnyType() ) {
+ throw new UnsupportedOperationException( "any not supported yet" );
+ }
+ else if ( type.isAssociationType() ) {
+ //collection or entity
+ if ( type.isCollectionType() ) {
+ //do collection
+ if ( value instanceof Collection ) {
+ Collection collValue = (Collection) value;
+ collValue.getCollectionType();
+ Value elementValue = collValue.getElement();
+ final org.hibernate.type.Type elementType = elementValue.getType();
+ if ( elementValue instanceof Component ) {
+ //colelction of components
+ return buildEmbeddableType( elementValue, elementType, context );
+ }
+ else if ( elementType.isAnyType() ) {
+ throw new UnsupportedOperationException( "collection of any not supported yet" );
+ }
+ else if ( elementType.isAssociationType() ) {
+ //collection of entity
+ return buildEntityType( elementType, context);
+ }
+ else {
+ //collection of basic type
+ buildBasicType( elementType );
+ }
+ }
+ else if ( value instanceof OneToMany ) {
+ //one to many with FK => entity
+ return buildEntityType( value.getType(), context );
+ }
+
+ }
+ else {
+ //ToOne association
+ return buildEntityType( type, context );
+ }
+ }
+ else if ( property.isComposite() ) {
+ //embeddable
+ return buildEmbeddableType( value, type, context );
+
+ }
+ else {
+ //basic type
+ return buildBasicType( type );
+ }
+ throw new UnsupportedOperationException("oops, we are missing something: " + property.toString() );
+ }
+
+ private static <X> Type<X> buildBasicType(org.hibernate.type.Type type) {
+ @SuppressWarnings( "unchecked" )
+ final Class<X> clazz = type.getReturnedClass();
+ return new BasicTypeImpl<X>( clazz, Type.PersistenceType.BASIC );
+ }
+
+ private static <X> Type<X> buildEntityType(org.hibernate.type.Type type, MetadataContext context) {
+ @SuppressWarnings( "unchecked" )
+ final Class<X> clazz = type.getReturnedClass();
+ final EntityTypeDelegator<X> entityTypeDelegator = new EntityTypeDelegator<X>();
+ context.addDelegator( entityTypeDelegator, clazz );
+ return entityTypeDelegator;
+ }
+
+ private static <X> Type<X> buildEmbeddableType(Value value, org.hibernate.type.Type type, MetadataContext context) {
+ //build embedable type
+ @SuppressWarnings( "unchecked" )
+ final Class<X> clazz = type.getReturnedClass();
+ Component component = (Component) value;
+ @SuppressWarnings( "unchecked")
+ final Iterator<Property> subProperties = component.getPropertyIterator();
+ final EmbeddableType<X> embeddableType = new EmbeddableTypeImpl<X>( clazz, subProperties, context );
+ context.addEmbeddableType( clazz, embeddableType );
+ return embeddableType;
+ }
+}
Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/MetamodelImpl.java
===================================================================
--- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/MetamodelImpl.java (rev 0)
+++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/MetamodelImpl.java 2009-08-09 18:04:35 UTC (rev 17254)
@@ -0,0 +1,81 @@
+package org.hibernate.ejb.metamodel;
+
+import java.util.Set;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Collections;
+import java.util.HashSet;
+import java.io.Serializable;
+import javax.persistence.metamodel.Metamodel;
+import javax.persistence.metamodel.EntityType;
+import javax.persistence.metamodel.ManagedType;
+import javax.persistence.metamodel.EmbeddableType;
+
+import org.hibernate.mapping.PersistentClass;
+
+/**
+ * @author Emmanuel Bernard
+ */
+public class MetamodelImpl implements Metamodel, Serializable {
+
+ private final Map<Class<?>,EntityType<?>> entities;
+ private Map<Class<?>, EmbeddableType<?>> embeddables;
+
+ public MetamodelImpl(Iterator<PersistentClass> classes) {
+ Map<Class<?>,EntityType<?>> localEntities = new HashMap<Class<?>,EntityType<?>>();
+ MetadataContext context = new MetadataContext();
+ while ( classes.hasNext() ) {
+ buildEntityType( classes, localEntities, context );
+ }
+ this.entities = Collections.unmodifiableMap( localEntities );
+ this.embeddables = Collections.unmodifiableMap( context.getEmbeddableTypes() );
+ context.postProcess( this );
+ }
+
+ private <X> void buildEntityType(Iterator<PersistentClass> classes, Map<Class<?>, EntityType<?>> localEntities, MetadataContext context) {
+ PersistentClass persistentClass = classes.next();
+ @SuppressWarnings( "unchecked" )
+ final Class<X> clazz = persistentClass.getMappedClass();
+ if ( clazz != null ) {
+ localEntities.put( clazz, new EntityTypeImpl<X>(clazz, persistentClass, context) );
+ }
+ }
+
+ public <X> EntityType<X> entity(Class<X> cls) {
+ final EntityType<?> entityType = entities.get( cls );
+ if ( entityType == null ) throw new IllegalArgumentException( "Not an entity: " + cls );
+ //unsafe casting is our map inserts guarantee them
+ return (EntityType<X>) entityType;
+ }
+
+ public <X> ManagedType<X> type(Class<X> cls) {
+ ManagedType<?> type = null;
+ type = entities.get( cls );
+ if ( type == null ) throw new IllegalArgumentException( "Not an managed type: " + cls );
+ //unsafe casting is our map inserts guarantee them
+ return (ManagedType<X>) type;
+ }
+
+ public <X> EmbeddableType<X> embeddable(Class<X> cls) {
+ final EmbeddableType<?> embeddableType = embeddables.get( cls );
+ if ( embeddableType == null ) throw new IllegalArgumentException( "Not an entity: " + cls );
+ //unsafe casting is our map inserts guarantee them
+ return (EmbeddableType<X>) embeddableType;
+ }
+
+ public Set<ManagedType<?>> getManagedTypes() {
+ final Set<ManagedType<?>> managedTypes = new HashSet<ManagedType<?>>( entities.size() + embeddables.size() );
+ managedTypes.addAll( entities.values() );
+ managedTypes.addAll( embeddables.values() );
+ return managedTypes;
+ }
+
+ public Set<EntityType<?>> getEntities() {
+ return new HashSet<EntityType<?>>(entities.values());
+ }
+
+ public Set<EmbeddableType<?>> getEmbeddables() {
+ return new HashSet<EmbeddableType<?>>(embeddables.values());
+ }
+}
Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/PluralAttributeImpl.java
===================================================================
--- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/PluralAttributeImpl.java (rev 0)
+++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/PluralAttributeImpl.java 2009-08-09 18:04:35 UTC (rev 17254)
@@ -0,0 +1,214 @@
+package org.hibernate.ejb.metamodel;
+
+import java.lang.reflect.Member;
+import java.util.Map;
+import java.util.List;
+import java.util.Set;
+import java.util.Collection;
+import javax.persistence.metamodel.PluralAttribute;
+import javax.persistence.metamodel.ManagedType;
+import javax.persistence.metamodel.Type;
+import javax.persistence.metamodel.SetAttribute;
+import javax.persistence.metamodel.CollectionAttribute;
+import javax.persistence.metamodel.ListAttribute;
+import javax.persistence.metamodel.MapAttribute;
+
+import org.hibernate.mapping.Property;
+
+/**
+ * @author Emmanuel Bernard
+ */
+public abstract class PluralAttributeImpl<X, C, E> implements PluralAttribute<X, C, E> {
+
+ private final ManagedType<X> ownerType;
+ private final Type<E> elementType;
+ //FIXME member is not serializable
+ private final Member member;
+ private final String name;
+ private final PersistentAttributeType persistentAttributeType;
+ private final Class<C> collectionClass;
+
+ private PluralAttributeImpl(Builder<X,C,E,?> builder) {
+ this.ownerType = builder.type;
+ this.elementType = builder.attributeType;
+ this.collectionClass = builder.collectionClass;
+ this.member = builder.member;
+ this.name = builder.property.getName();
+ this.persistentAttributeType = builder.persistentAttributeType;
+ }
+
+ public static class Builder<X, C, E, K> {
+ private final Type<E> attributeType;
+ private final ManagedType<X> type;
+ private Member member;
+ private PersistentAttributeType persistentAttributeType;
+ private Property property;
+ private Class<C> collectionClass;
+ private Type<K> keyType;
+
+
+ private Builder(ManagedType<X> ownerType, Type<E> attrType, Class<C> collectionClass, Type<K> keyType) {
+ this.type = ownerType;
+ this.attributeType = attrType;
+ this.collectionClass = collectionClass;
+ this.keyType = keyType;
+ }
+
+ public Builder<X,C,E,K> member(Member member) {
+ this.member = member;
+ return this;
+ }
+
+ public Builder<X,C,E,K> property(Property property) {
+ this.property = property;
+ return this;
+ }
+
+ public Builder<X,C,E,K> persistentAttributeType(PersistentAttributeType attrType) {
+ this.persistentAttributeType = attrType;
+ return this;
+ }
+
+ public <K> PluralAttributeImpl<X,C,E> build() {
+ if ( Map.class.isAssignableFrom( collectionClass ) ) {
+ @SuppressWarnings( "unchecked" )
+ final Builder<X,Map<K,E>,E,K> builder = (Builder<X,Map<K,E>,E,K>) this;
+ @SuppressWarnings( "unchecked" )
+ final PluralAttributeImpl<X, C, E> result = ( PluralAttributeImpl<X, C, E> ) new MapAttributeImpl<X,K,E>(
+ builder
+ );
+ return result;
+ }
+ else if ( Set.class.isAssignableFrom( collectionClass ) ) {
+ @SuppressWarnings( "unchecked" )
+ final Builder<X,Set<E>, E,?> builder = (Builder<X, Set<E>, E,?>) this;
+ @SuppressWarnings( "unchecked" )
+ final PluralAttributeImpl<X, C, E> result = ( PluralAttributeImpl<X, C, E> ) new SetAttributeImpl<X,E>(
+ builder
+ );
+ return result;
+ }
+ else if ( List.class.isAssignableFrom( collectionClass ) ) {
+ @SuppressWarnings( "unchecked" )
+ final Builder<X, List<E>, E,?> builder = (Builder<X, List<E>, E,?>) this;
+ @SuppressWarnings( "unchecked" )
+ final PluralAttributeImpl<X, C, E> result = ( PluralAttributeImpl<X, C, E> ) new ListAttributeImpl<X,E>(
+ builder
+ );
+ return result;
+ }
+ else if ( Collection.class.isAssignableFrom( collectionClass ) ) {
+ @SuppressWarnings( "unchecked" )
+ final Builder<X, Collection<E>,E,?> builder = (Builder<X, Collection<E>, E,?>) this;
+ @SuppressWarnings( "unchecked" )
+ final PluralAttributeImpl<X, C, E> result = ( PluralAttributeImpl<X, C, E> ) new CollectionAttributeImpl<X, E>(
+ builder
+ );
+ return result;
+ }
+ throw new UnsupportedOperationException( "Unkown collection: " + collectionClass );
+ }
+ }
+
+ public static <X,C,E,K> Builder<X,C,E,K> create(
+ ManagedType<X> ownerType,
+ Type<E> attrType,
+ Class<C> collectionClass,
+ Type<K> keyType) {
+ return new Builder<X,C,E,K>(ownerType, attrType, collectionClass, keyType);
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public PersistentAttributeType getPersistentAttributeType() {
+ return persistentAttributeType;
+ }
+
+ public ManagedType<X> getDeclaringType() {
+ return ownerType;
+ }
+
+ public Class<C> getJavaType() {
+ return collectionClass;
+ }
+
+ public abstract CollectionType getCollectionType();
+
+ public Type<E> getElementType() {
+ return elementType;
+ }
+
+
+ public Member getJavaMember() {
+ return member;
+ }
+
+ public boolean isAssociation() {
+ return true;
+ }
+
+ public boolean isCollection() {
+ return true;
+ }
+
+ public BindableType getBindableType() {
+ return BindableType.PLURAL_ATTRIBUTE;
+ }
+
+ public Class<E> getBindableJavaType() {
+ return elementType.getJavaType();
+ }
+
+ static class SetAttributeImpl<X,E> extends PluralAttributeImpl<X,Set<E>,E> implements SetAttribute<X,E> {
+ SetAttributeImpl(Builder<X,Set<E>,E,?> xceBuilder) {
+ super( xceBuilder );
+ }
+
+ public CollectionType getCollectionType() {
+ return CollectionType.SET;
+ }
+ }
+
+ static class CollectionAttributeImpl<X,E> extends PluralAttributeImpl<X,Collection<E>,E> implements CollectionAttribute<X,E> {
+ CollectionAttributeImpl(Builder<X, Collection<E>,E,?> xceBuilder) {
+ super( xceBuilder );
+ }
+
+ public CollectionType getCollectionType() {
+ return CollectionType.COLLECTION;
+ }
+ }
+
+ static class ListAttributeImpl<X,E> extends PluralAttributeImpl<X,List<E>,E> implements ListAttribute<X,E> {
+ ListAttributeImpl(Builder<X,List<E>,E,?> xceBuilder) {
+ super( xceBuilder );
+ }
+
+ public CollectionType getCollectionType() {
+ return CollectionType.LIST;
+ }
+ }
+
+ static class MapAttributeImpl<X,K,V> extends PluralAttributeImpl<X,Map<K,V>,V> implements MapAttribute<X,K,V> {
+ private final Type<K> keyType;
+
+ MapAttributeImpl(Builder<X,Map<K,V>,V,K> xceBuilder) {
+ super( xceBuilder );
+ this.keyType = xceBuilder.keyType;
+ }
+
+ public CollectionType getCollectionType() {
+ return CollectionType.MAP;
+ }
+
+ public Class<K> getKeyJavaType() {
+ return keyType.getJavaType();
+ }
+
+ public Type<K> getKeyType() {
+ return keyType;
+ }
+ }
+}
Added: core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/SingularAttributeImpl.java
===================================================================
--- core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/SingularAttributeImpl.java (rev 0)
+++ core/trunk/entitymanager/src/main/java/org/hibernate/ejb/metamodel/SingularAttributeImpl.java 2009-08-09 18:04:35 UTC (rev 17254)
@@ -0,0 +1,146 @@
+package org.hibernate.ejb.metamodel;
+
+import java.lang.reflect.Member;
+import java.io.Serializable;
+import javax.persistence.metamodel.ManagedType;
+import javax.persistence.metamodel.SingularAttribute;
+import javax.persistence.metamodel.Type;
+
+import org.hibernate.mapping.Property;
+
+/**
+ * @author Emmanuel Bernard
+ */
+public class SingularAttributeImpl<X, Y> implements SingularAttribute<X, Y>, Serializable {
+ private final boolean isId;
+ private final boolean isVersion;
+ private final boolean isOptional;
+ private final ManagedType<X> ownerType;
+ private final Type<Y> attrType;
+ //FIXME member is not serializable
+ private final Member member;
+ private final String name;
+ private final PersistentAttributeType persistentAttributeType;
+
+ private SingularAttributeImpl(Builder<X,Y> builder) {
+ this.ownerType = builder.type;
+ this.attrType = builder.attributeType;
+ this.isId = builder.isId;
+ this.isVersion = builder.isVersion;
+ final Property property = builder.property;
+ this.isOptional = property.isOptional();
+ this.member = builder.member;
+ this.name = property.getName();
+ if ( builder.persistentAttributeType != null) {
+ this.persistentAttributeType = builder.persistentAttributeType;
+ }
+ else {
+ this.persistentAttributeType = property.isComposite() ?
+ PersistentAttributeType.EMBEDDED :
+ PersistentAttributeType.BASIC;
+ }
+ }
+
+ public static class Builder<X,Y> {
+ private boolean isId;
+ private boolean isVersion;
+ //private boolean isOptional = true;
+ private final Type<Y> attributeType;
+ private final ManagedType<X> type;
+ private Member member;
+ //private String name;
+ private PersistentAttributeType persistentAttributeType;
+ private Property property;
+
+
+ private Builder(ManagedType<X> ownerType, Type<Y> attrType) {
+ this.type = ownerType;
+ this.attributeType = attrType;
+ }
+
+ public Builder<X,Y> member(Member member) {
+ this.member = member;
+ return this;
+ }
+
+ public Builder<X, Y> property(Property property) {
+ this.property = property;
+ return this;
+ }
+
+ public Builder<X,Y> id() {
+ isId = true;
+ return this;
+ }
+
+ public Builder<X,Y> version() {
+ isVersion = true;
+ return this;
+ }
+
+ public SingularAttribute<X, Y> build() {
+ return new SingularAttributeImpl<X,Y>(this);
+ }
+
+ public Builder<X, Y> persistentAttributeType(PersistentAttributeType attrType) {
+ this.persistentAttributeType = attrType;
+ return this;
+ }
+ }
+
+ public static <X,Y> Builder<X,Y> create(ManagedType<X> ownerType, Type<Y> attrType) {
+ return new Builder<X,Y>(ownerType, attrType);
+ }
+
+ public boolean isId() {
+ return isId;
+ }
+
+ public boolean isVersion() {
+ return isVersion;
+ }
+
+ public boolean isOptional() {
+ return isOptional;
+ }
+
+ public Type<Y> getType() {
+ return attrType;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public PersistentAttributeType getPersistentAttributeType() {
+ return persistentAttributeType;
+ }
+
+ public ManagedType<X> getDeclaringType() {
+ return ownerType;
+ }
+
+ public Class<Y> getJavaType() {
+ return attrType.getJavaType();
+ }
+
+ public Member getJavaMember() {
+ return member;
+ }
+
+ public boolean isAssociation() {
+ return false;
+ }
+
+ public boolean isCollection() {
+ return false;
+ }
+
+ public BindableType getBindableType() {
+ return BindableType.SINGULAR_ATTRIBUTE;
+ }
+
+ public Class<Y> getBindableJavaType() {
+ return attrType.getJavaType();
+ }
+}
More information about the hibernate-commits
mailing list