org.eclipse.osbp.dsl.dto.lib/src/org/eclipse/osbp/dsl/dto/lib/services/jpa/metadata/MetadataFactory.java - osbp/org.eclipse.osbp.dsl - Git at Google

 /**
  * Copyright 2009-2013 Oy Vaadin Ltd
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *    http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package org.eclipse.osbp.dsl.dto.lib.services.jpa.metadata;

 import java.beans.Introspector;
 import java.lang.reflect.AccessibleObject;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.util.HashMap;
 import java.util.Map;

 import javax.persistence.ElementCollection;
 import javax.persistence.Embeddable;
 import javax.persistence.Embedded;
 import javax.persistence.EmbeddedId;
 import javax.persistence.Entity;
 import javax.persistence.Id;
 import javax.persistence.ManyToMany;
 import javax.persistence.ManyToOne;
 import javax.persistence.MappedSuperclass;
 import javax.persistence.OneToMany;
 import javax.persistence.OneToOne;
 import javax.persistence.Transient;
 import javax.persistence.Version;

 import org.eclipse.osbp.dsl.dto.lib.services.jpa.metadata.PersistentPropertyMetadata.AccessType;

 /**
  * Factory for creating and populating {@link ClassMetadata} and
  * {@link EntityClassMetadata} instances.
  *
  * @author Petter Holmström (Vaadin Ltd)
  * @since 1.0
  */
 public class MetadataFactory {

     private static MetadataFactory INSTANCE;
     private Map<Class<?>, ClassMetadata<?>> metadataMap = new HashMap<Class<?>, ClassMetadata<?>>();

     protected MetadataFactory() {
         // NOP
     }

     /**
      * Gets the singleton instance of this factory.
      *
      * @return the factory instance (never null).
      */
     public static MetadataFactory getInstance() {
         if (INSTANCE == null) {
             INSTANCE = new MetadataFactory();
         }
         return INSTANCE;
     }

     /**
      * Extracts the entity class metadata from <code>mappedClass</code>. The
      * access type (field or method) will be determined from the location of the
      * {@link Id} or {@link EmbeddedId} annotation. If both of these are
      * missing, this method will fail. This method will also fail if
      * <code>mappedClass</code> lacks the {@link Entity} annotation.
      *
      * @param mappedClass
      *            the mapped class (must not be null).
      * @return the class metadata.
      * @throws IllegalArgumentException
      *             if no metadata could be extracted.
      */
     public <T> EntityClassMetadata<T> getEntityClassMetadata(
             Class<T> mappedClass) throws IllegalArgumentException {
         assert mappedClass != null : "mappedClass must not be null";
         if (mappedClass.getAnnotation(Entity.class) == null) {
             throw new IllegalArgumentException("The class is not an entity");
         }
         PersistentPropertyMetadata.AccessType accessType = determineAccessType(mappedClass);
         if (accessType == null) {
             throw new IllegalArgumentException(
                     "The access type could not be determined");
         } else {
             return (EntityClassMetadata<T>) getClassMetadata(mappedClass,
                     accessType);
         }
     }

     /**
      * Extracts the class metadata from <code>mappedClass</code>. If
      * <code>mappedClass</code> is {@link Embeddable}, the result will be an
      * instance of {@link ClassMetadata}. If <code>mappedClass</code> is an
      * {@link Entity}, the result will be an instance of
      * {@link EntityClassMetadata}.
      * <p>
      * <code>accessType</code> instructs the factory where to look for
      * annotations and which defaults to assume if there are no annotations.
      *
      * @param mappedClass
      *            the mapped class (must not be null).
      * @param accessType
      *            the location where to look for annotations (must not be null).
      * @return the class metadata.
      * @throws IllegalArgumentException
      *             if no metadata could be extracted.
      */
     @SuppressWarnings("unchecked")
     public <T> ClassMetadata<T> getClassMetadata(Class<T> mappedClass,
             PersistentPropertyMetadata.AccessType accessType)
             throws IllegalArgumentException {
         assert mappedClass != null : "mappedClass must not be null";
         assert accessType != null : "accessType must not be null";

         // Check if we already have the metadata in cache
         ClassMetadata<T> metadata = (ClassMetadata<T>) metadataMap
                 .get(mappedClass);
         if (metadata != null) {
             return metadata;
         }

         // Check if we are dealing with an entity class or an embeddable class
         Entity entity = mappedClass.getAnnotation(Entity.class);
         Embeddable embeddable = mappedClass.getAnnotation(Embeddable.class);
         if (entity != null) {
             // We have an entity class
             String entityName = entity.name().length() == 0 ? mappedClass
                     .getSimpleName() : entity.name();
             metadata = new EntityClassMetadata<T>(mappedClass, entityName);
             // Put the metadata instance in the cache in case it is referenced
             // from loadProperties()
             metadataMap.put(mappedClass, metadata);
             loadProperties(mappedClass, metadata, accessType);

             // Locate the version and identifier properties
             EntityClassMetadata<T> entityMetadata = (EntityClassMetadata<T>) metadata;
             for (PersistentPropertyMetadata pm : entityMetadata
                     .getPersistentProperties()) {

                 if (pm.getAnnotation(Version.class) != null) {
                     entityMetadata.setVersionPropertyName(pm.getName());
                 } else if (pm.getAnnotation(Id.class) != null
                         || pm.getAnnotation(EmbeddedId.class) != null) {
                     entityMetadata.setIdentifierPropertyName(pm.getName());
                 }
                 if (entityMetadata.hasIdentifierProperty()
                         && entityMetadata.hasVersionProperty()) {
                     // No use continuing the loop if both the version
                     // and the identifier property have already been found.
                     break;
                 }
             }
         } else if (embeddable != null) {
             // We have an embeddable class
             metadata = new ClassMetadata<T>(mappedClass);
             // Put the metadata instance in the cache in case it is referenced
             // from loadProperties()
             metadataMap.put(mappedClass, metadata);
             loadProperties(mappedClass, metadata, accessType);
         } else {
             throw new IllegalArgumentException("The class "
                     + mappedClass.getName()
                     + " is nether an entity nor embeddable");
         }

         return metadata;
     }

     protected void loadProperties(Class<?> type, ClassMetadata<?> metadata,
             PersistentPropertyMetadata.AccessType accessType) {

         // Also check superclass for metadata
         Class<?> superclass = type.getSuperclass();
         if (superclass != null
         		&& (superclass.getAnnotation(MappedSuperclass.class) != null
                     || superclass.getAnnotation(Entity.class) != null )
 //TODO: check the change made for SONAR !!!
                 || (superclass != null
                     && superclass.getAnnotation(Embeddable.class) != null)
         	) {
             loadProperties(superclass, metadata, accessType);
         }

         if (accessType == PersistentPropertyMetadata.AccessType.FIELD) {
             extractPropertiesFromFields(type, metadata);
         } else {
             extractPropertiesFromMethods(type, metadata);
         }
     }

     protected PersistentPropertyMetadata.AccessType determineAccessType(
             Class<?> type) {
         // Start by looking for annotated fields
         for (Field f : type.getDeclaredFields()) {
             if (f.getAnnotation(Id.class) != null
                     || f.getAnnotation(EmbeddedId.class) != null) {
                 return AccessType.FIELD;
             }
         }

         // Then look for annotated getter methods
         for (Method m : type.getDeclaredMethods()) {
             if (m.getAnnotation(Id.class) != null
                     || m.getAnnotation(EmbeddedId.class) != null) {
                 return AccessType.METHOD;
             }
         }

         // Nothing found? Try with the superclass!
         Class<?> superclass = type.getSuperclass();
         if (superclass != null
                 && (superclass.getAnnotation(MappedSuperclass.class) != null || superclass
                         .getAnnotation(Entity.class) != null)) {
             return determineAccessType(superclass);
         }

         // The access type could not be determined;
         return null;
     }

     protected boolean isReference(AccessibleObject ab) {
         return ab.getAnnotation(ManyToOne.class) != null;
     }

     private boolean isOneToOne(AccessibleObject ab) {
         return ab.getAnnotation(OneToOne.class) != null;
     }

     protected boolean isCollection(AccessibleObject ab) {
         return ab.getAnnotation(OneToMany.class) != null;
     }

     private boolean isManyToMany(AccessibleObject ab) {
         return ab.getAnnotation(ManyToMany.class) != null;
     }

     protected boolean isEmbedded(AccessibleObject ab) {
         return (ab.getAnnotation(Embedded.class) != null || ab
                 .getAnnotation(EmbeddedId.class) != null);
     }

     protected void extractPropertiesFromFields(Class<?> type,
             ClassMetadata<?> metadata) {
         for (Field f : type.getDeclaredFields()) {
             int mod = f.getModifiers();
             if (!Modifier.isFinal(mod) && !Modifier.isStatic(mod)
                     && !Modifier.isTransient(mod)
                     && f.getAnnotation(Transient.class) == null) {
                 Class<?> fieldType = getFieldType(f);
                 Method setterMethod = null;
                 try {
                     final String assumedSetterName = "set"
                             + f.getName().substring(0, 1).toUpperCase()
                             + f.getName().substring(1);
                     Method method = type
                             .getMethod(assumedSetterName, fieldType);
                     setterMethod = method;
                 } catch (Exception e) {
                     // Setter does not exist or is not accessible
                 }

                 if (isEmbedded(f)) {
                     ClassMetadata<?> cm = getClassMetadata(fieldType,
                             AccessType.FIELD);
                     metadata.addProperties(new PersistentPropertyMetadata(f
                             .getName(), cm, PropertyKind.EMBEDDED, f,
                             setterMethod));
                 } else if (isReference(f)) {
                     ClassMetadata<?> cm = getClassMetadata(fieldType,
                             AccessType.FIELD);
                     metadata.addProperties(new PersistentPropertyMetadata(f
                             .getName(), cm, PropertyKind.MANY_TO_ONE, f,
                             setterMethod));
                 } else if (isOneToOne(f)) {
                     ClassMetadata<?> cm = getClassMetadata(fieldType,
                             AccessType.FIELD);
                     metadata.addProperties(new PersistentPropertyMetadata(f
                             .getName(), cm, PropertyKind.ONE_TO_ONE, f,
                             setterMethod));
                 } else if (isCollection(f)) {
                     metadata.addProperties(new PersistentPropertyMetadata(f
                             .getName(), fieldType, PropertyKind.ONE_TO_MANY, f,
                             setterMethod));
                 } else if (isManyToMany(f)) {
                     metadata.addProperties(new PersistentPropertyMetadata(f
                             .getName(), fieldType, PropertyKind.MANY_TO_MANY,
                             f, setterMethod));
                 } else if (isElementCollection(f)) {
                     metadata.addProperties(new PersistentPropertyMetadata(f
                             .getName(), fieldType,
                             PropertyKind.ELEMENT_COLLECTION, f, setterMethod));
                 } else {
                     metadata.addProperties(new PersistentPropertyMetadata(f
                             .getName(), convertPrimitiveType(fieldType),
                             PropertyKind.SIMPLE, f, setterMethod));
                 }
             }
         }
         // Find the transient properties
         for (Method m : type.getDeclaredMethods()) {
             int mod = m.getModifiers();
             // Synthetic methods are excluded (#4590).
             // In theory, this could filter out too much in some special cases,
             // in which case the subclass could re-declare the accessor methods
             // with the correct annotations as a workaround.
             if (m.getName().startsWith("get") && m.getName().length() > 3
                     && !Modifier.isStatic(mod) && !m.isSynthetic()
                     && m.getReturnType() != Void.TYPE
                     && m.getParameterTypes().length == 0) {
                 Method setter = null;
                 try {
                     // Check if we have a setter
                     setter = type.getDeclaredMethod("set"
                             + m.getName().substring(3), m.getReturnType());
                 } catch (NoSuchMethodException ignoreit) {
                 }
                 String name = Introspector.decapitalize(m.getName()
                         .substring(3));

                 if (metadata.getProperty(name) == null) {
                     // No previous property has been added with the same name
                     metadata.addProperties(new PropertyMetadata(name, m
                             .getReturnType(), m, setter));
                 }
             }
         }
     }

     protected boolean isElementCollection(AccessibleObject ab) {
         return (ab.getAnnotation(ElementCollection.class) != null);
     }

     /**
      * Finds the actual pointed-to type of the field. The concrete type may be
      * other than the declared type if the targetEntity parameter is specified
      * in certain annotations.
      *
      * @param f
      *            the field.
      * @return the type of the field.
      */
     private Class<?> getFieldType(Field f) {
         Class<?> targetEntity = void.class;
         if (isReference(f)) {
             targetEntity = f.getAnnotation(ManyToOne.class).targetEntity();
         } else if (isOneToOne(f)) {
             targetEntity = f.getAnnotation(OneToOne.class).targetEntity();
         }
         if (targetEntity != void.class) {
             return targetEntity;
         }
         return f.getType();
     }

     private Class<?> convertPrimitiveType(Class<?> type) {
         // Vaadin fields don't work with primitive values, use wrapper types for
         // primitives
         if (type.isPrimitive()) {
             if (type.equals(Boolean.TYPE)) {
                 type = Boolean.class;
             } else if (type.equals(Integer.TYPE)) {
                 type = Integer.class;
             } else if (type.equals(Float.TYPE)) {
                 type = Float.class;
             } else if (type.equals(Double.TYPE)) {
                 type = Double.class;
             } else if (type.equals(Byte.TYPE)) {
                 type = Byte.class;
             } else if (type.equals(Character.TYPE)) {
                 type = Character.class;
             } else if (type.equals(Short.TYPE)) {
                 type = Short.class;
             } else if (type.equals(Long.TYPE)) {
                 type = Long.class;
             }
         }
         return type;
     }

     protected void extractPropertiesFromMethods(Class<?> type,
             ClassMetadata<?> metadata) {
         for (Method m : type.getDeclaredMethods()) {
             int mod = m.getModifiers();
             // Synthetic methods are excluded (#4590) - otherwise you could e.g.
             // have a synthetic and a concrete id getter (with different
             // declared return types) in TestClasses.Integer_ConcreteId_M, and
             // the synthetic method could override the concrete one and its
             // annotations.
             // In theory, this could filter out too much in some special cases,
             // in which case the subclass could re-declare the accessor methods
             // with the correct annotations as a workaround.
             if (m.getName().startsWith("get") && m.getName().length() > 3
                     && !Modifier.isStatic(mod) && !m.isSynthetic()
                     && m.getReturnType() != Void.TYPE
                     && m.getParameterTypes().length == 0) {
                 Method setter = null;
                 try {
                     // Check if we have a setter
                     setter = type.getDeclaredMethod("set"
                             + m.getName().substring(3), m.getReturnType());
                 } catch (NoSuchMethodException ignoreit) {
                     // No setter <=> transient property
                 }
                 String name = Introspector.decapitalize(m.getName()
                         .substring(3));

                 if (setter != null && m.getAnnotation(Transient.class) == null) {
                     // Persistent property
                     if (isEmbedded(m)) {
                         ClassMetadata<?> cm = getClassMetadata(
                                 m.getReturnType(), AccessType.METHOD);
                         metadata.addProperties(new PersistentPropertyMetadata(
                                 name, cm, PropertyKind.EMBEDDED, m, setter));
                     } else if (isReference(m)) {
                         ClassMetadata<?> cm = getClassMetadata(
                                 m.getReturnType(), AccessType.METHOD);
                         metadata.addProperties(new PersistentPropertyMetadata(
                                 name, cm, PropertyKind.MANY_TO_ONE, m, setter));
                     } else if (isOneToOne(m)) {
                         ClassMetadata<?> cm = getClassMetadata(
                                 m.getReturnType(), AccessType.METHOD);
                         metadata.addProperties(new PersistentPropertyMetadata(
                                 name, cm, PropertyKind.ONE_TO_ONE, m, setter));
                     } else if (isCollection(m)) {
                         metadata.addProperties(new PersistentPropertyMetadata(
                                 name, m.getReturnType(),
                                 PropertyKind.ONE_TO_MANY, m, setter));
                     } else if (isManyToMany(m)) {
                         metadata.addProperties(new PersistentPropertyMetadata(
                                 name, m.getReturnType(),
                                 PropertyKind.MANY_TO_MANY, m, setter));
                     } else if (isElementCollection(m)) {
                         metadata.addProperties(new PersistentPropertyMetadata(
                                 name, m.getReturnType(),
                                 PropertyKind.ELEMENT_COLLECTION, m, setter));
                     } else {
                         metadata.addProperties(new PersistentPropertyMetadata(
                                 name, m.getReturnType(), PropertyKind.SIMPLE,
                                 m, setter));
                     }
                 } else {
                     // Transient property
                     metadata.addProperties(new PropertyMetadata(name, m
                             .getReturnType(), m, setter));
                 }
             }
         }
     }
 }
	/**
	* Copyright 2009-2013 Oy Vaadin Ltd
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package org.eclipse.osbp.dsl.dto.lib.services.jpa.metadata;

	import java.beans.Introspector;
	import java.lang.reflect.AccessibleObject;
	import java.lang.reflect.Field;
	import java.lang.reflect.Method;
	import java.lang.reflect.Modifier;
	import java.util.HashMap;
	import java.util.Map;

	import javax.persistence.ElementCollection;
	import javax.persistence.Embeddable;
	import javax.persistence.Embedded;
	import javax.persistence.EmbeddedId;
	import javax.persistence.Entity;
	import javax.persistence.Id;
	import javax.persistence.ManyToMany;
	import javax.persistence.ManyToOne;
	import javax.persistence.MappedSuperclass;
	import javax.persistence.OneToMany;
	import javax.persistence.OneToOne;
	import javax.persistence.Transient;
	import javax.persistence.Version;

	import org.eclipse.osbp.dsl.dto.lib.services.jpa.metadata.PersistentPropertyMetadata.AccessType;

	/**
	* Factory for creating and populating {@link ClassMetadata} and
	* {@link EntityClassMetadata} instances.
	*
	* @author Petter Holmström (Vaadin Ltd)
	* @since 1.0
	*/
	public class MetadataFactory {

	private static MetadataFactory INSTANCE;
	private Map<Class<?>, ClassMetadata<?>> metadataMap = new HashMap<Class<?>, ClassMetadata<?>>();

	protected MetadataFactory() {
	// NOP
	}

	/**
	* Gets the singleton instance of this factory.
	*
	* @return the factory instance (never null).
	*/
	public static MetadataFactory getInstance() {
	if (INSTANCE == null) {
	INSTANCE = new MetadataFactory();
	}
	return INSTANCE;
	}

	/**
	* Extracts the entity class metadata from <code>mappedClass</code>. The
	* access type (field or method) will be determined from the location of the
	* {@link Id} or {@link EmbeddedId} annotation. If both of these are
	* missing, this method will fail. This method will also fail if
	* <code>mappedClass</code> lacks the {@link Entity} annotation.
	*
	* @param mappedClass
	* the mapped class (must not be null).
	* @return the class metadata.
	* @throws IllegalArgumentException
	* if no metadata could be extracted.
	*/
	public <T> EntityClassMetadata<T> getEntityClassMetadata(
	Class<T> mappedClass) throws IllegalArgumentException {
	assert mappedClass != null : "mappedClass must not be null";
	if (mappedClass.getAnnotation(Entity.class) == null) {
	throw new IllegalArgumentException("The class is not an entity");
	}
	PersistentPropertyMetadata.AccessType accessType = determineAccessType(mappedClass);
	if (accessType == null) {
	throw new IllegalArgumentException(
	"The access type could not be determined");
	} else {
	return (EntityClassMetadata<T>) getClassMetadata(mappedClass,
	accessType);
	}
	}

	/**
	* Extracts the class metadata from <code>mappedClass</code>. If
	* <code>mappedClass</code> is {@link Embeddable}, the result will be an
	* instance of {@link ClassMetadata}. If <code>mappedClass</code> is an
	* {@link Entity}, the result will be an instance of
	* {@link EntityClassMetadata}.
	* <p>
	* <code>accessType</code> instructs the factory where to look for
	* annotations and which defaults to assume if there are no annotations.
	*
	* @param mappedClass
	* the mapped class (must not be null).
	* @param accessType
	* the location where to look for annotations (must not be null).
	* @return the class metadata.
	* @throws IllegalArgumentException
	* if no metadata could be extracted.
	*/
	@SuppressWarnings("unchecked")
	public <T> ClassMetadata<T> getClassMetadata(Class<T> mappedClass,
	PersistentPropertyMetadata.AccessType accessType)
	throws IllegalArgumentException {
	assert mappedClass != null : "mappedClass must not be null";
	assert accessType != null : "accessType must not be null";

	// Check if we already have the metadata in cache
	ClassMetadata<T> metadata = (ClassMetadata<T>) metadataMap
	.get(mappedClass);
	if (metadata != null) {
	return metadata;
	}

	// Check if we are dealing with an entity class or an embeddable class
	Entity entity = mappedClass.getAnnotation(Entity.class);
	Embeddable embeddable = mappedClass.getAnnotation(Embeddable.class);
	if (entity != null) {
	// We have an entity class
	String entityName = entity.name().length() == 0 ? mappedClass
	.getSimpleName() : entity.name();
	metadata = new EntityClassMetadata<T>(mappedClass, entityName);
	// Put the metadata instance in the cache in case it is referenced
	// from loadProperties()
	metadataMap.put(mappedClass, metadata);
	loadProperties(mappedClass, metadata, accessType);

	// Locate the version and identifier properties
	EntityClassMetadata<T> entityMetadata = (EntityClassMetadata<T>) metadata;
	for (PersistentPropertyMetadata pm : entityMetadata
	.getPersistentProperties()) {

	if (pm.getAnnotation(Version.class) != null) {
	entityMetadata.setVersionPropertyName(pm.getName());
	} else if (pm.getAnnotation(Id.class) != null
	\|\| pm.getAnnotation(EmbeddedId.class) != null) {
	entityMetadata.setIdentifierPropertyName(pm.getName());
	}
	if (entityMetadata.hasIdentifierProperty()
	&& entityMetadata.hasVersionProperty()) {
	// No use continuing the loop if both the version
	// and the identifier property have already been found.
	break;
	}
	}
	} else if (embeddable != null) {
	// We have an embeddable class
	metadata = new ClassMetadata<T>(mappedClass);
	// Put the metadata instance in the cache in case it is referenced
	// from loadProperties()
	metadataMap.put(mappedClass, metadata);
	loadProperties(mappedClass, metadata, accessType);
	} else {
	throw new IllegalArgumentException("The class "
	+ mappedClass.getName()
	+ " is nether an entity nor embeddable");
	}

	return metadata;
	}

	protected void loadProperties(Class<?> type, ClassMetadata<?> metadata,
	PersistentPropertyMetadata.AccessType accessType) {

	// Also check superclass for metadata
	Class<?> superclass = type.getSuperclass();
	if (superclass != null
	&& (superclass.getAnnotation(MappedSuperclass.class) != null
	\|\| superclass.getAnnotation(Entity.class) != null )
	//TODO: check the change made for SONAR !!!
	\|\| (superclass != null
	&& superclass.getAnnotation(Embeddable.class) != null)
	) {
	loadProperties(superclass, metadata, accessType);
	}

	if (accessType == PersistentPropertyMetadata.AccessType.FIELD) {
	extractPropertiesFromFields(type, metadata);
	} else {
	extractPropertiesFromMethods(type, metadata);
	}
	}

	protected PersistentPropertyMetadata.AccessType determineAccessType(
	Class<?> type) {
	// Start by looking for annotated fields
	for (Field f : type.getDeclaredFields()) {
	if (f.getAnnotation(Id.class) != null
	\|\| f.getAnnotation(EmbeddedId.class) != null) {
	return AccessType.FIELD;
	}
	}

	// Then look for annotated getter methods
	for (Method m : type.getDeclaredMethods()) {
	if (m.getAnnotation(Id.class) != null
	\|\| m.getAnnotation(EmbeddedId.class) != null) {
	return AccessType.METHOD;
	}
	}

	// Nothing found? Try with the superclass!
	Class<?> superclass = type.getSuperclass();
	if (superclass != null
	&& (superclass.getAnnotation(MappedSuperclass.class) != null \|\| superclass
	.getAnnotation(Entity.class) != null)) {
	return determineAccessType(superclass);
	}

	// The access type could not be determined;
	return null;
	}

	protected boolean isReference(AccessibleObject ab) {
	return ab.getAnnotation(ManyToOne.class) != null;
	}

	private boolean isOneToOne(AccessibleObject ab) {
	return ab.getAnnotation(OneToOne.class) != null;
	}

	protected boolean isCollection(AccessibleObject ab) {
	return ab.getAnnotation(OneToMany.class) != null;
	}

	private boolean isManyToMany(AccessibleObject ab) {
	return ab.getAnnotation(ManyToMany.class) != null;
	}

	protected boolean isEmbedded(AccessibleObject ab) {
	return (ab.getAnnotation(Embedded.class) != null \|\| ab
	.getAnnotation(EmbeddedId.class) != null);
	}

	protected void extractPropertiesFromFields(Class<?> type,
	ClassMetadata<?> metadata) {
	for (Field f : type.getDeclaredFields()) {
	int mod = f.getModifiers();
	if (!Modifier.isFinal(mod) && !Modifier.isStatic(mod)
	&& !Modifier.isTransient(mod)
	&& f.getAnnotation(Transient.class) == null) {
	Class<?> fieldType = getFieldType(f);
	Method setterMethod = null;
	try {
	final String assumedSetterName = "set"
	+ f.getName().substring(0, 1).toUpperCase()
	+ f.getName().substring(1);
	Method method = type
	.getMethod(assumedSetterName, fieldType);
	setterMethod = method;
	} catch (Exception e) {
	// Setter does not exist or is not accessible
	}

	if (isEmbedded(f)) {
	ClassMetadata<?> cm = getClassMetadata(fieldType,
	AccessType.FIELD);
	metadata.addProperties(new PersistentPropertyMetadata(f
	.getName(), cm, PropertyKind.EMBEDDED, f,
	setterMethod));
	} else if (isReference(f)) {
	ClassMetadata<?> cm = getClassMetadata(fieldType,
	AccessType.FIELD);
	metadata.addProperties(new PersistentPropertyMetadata(f
	.getName(), cm, PropertyKind.MANY_TO_ONE, f,
	setterMethod));
	} else if (isOneToOne(f)) {
	ClassMetadata<?> cm = getClassMetadata(fieldType,
	AccessType.FIELD);
	metadata.addProperties(new PersistentPropertyMetadata(f
	.getName(), cm, PropertyKind.ONE_TO_ONE, f,
	setterMethod));
	} else if (isCollection(f)) {
	metadata.addProperties(new PersistentPropertyMetadata(f
	.getName(), fieldType, PropertyKind.ONE_TO_MANY, f,
	setterMethod));
	} else if (isManyToMany(f)) {
	metadata.addProperties(new PersistentPropertyMetadata(f
	.getName(), fieldType, PropertyKind.MANY_TO_MANY,
	f, setterMethod));
	} else if (isElementCollection(f)) {
	metadata.addProperties(new PersistentPropertyMetadata(f
	.getName(), fieldType,
	PropertyKind.ELEMENT_COLLECTION, f, setterMethod));
	} else {
	metadata.addProperties(new PersistentPropertyMetadata(f
	.getName(), convertPrimitiveType(fieldType),
	PropertyKind.SIMPLE, f, setterMethod));
	}
	}
	}
	// Find the transient properties
	for (Method m : type.getDeclaredMethods()) {
	int mod = m.getModifiers();
	// Synthetic methods are excluded (#4590).
	// In theory, this could filter out too much in some special cases,
	// in which case the subclass could re-declare the accessor methods
	// with the correct annotations as a workaround.
	if (m.getName().startsWith("get") && m.getName().length() > 3
	&& !Modifier.isStatic(mod) && !m.isSynthetic()
	&& m.getReturnType() != Void.TYPE
	&& m.getParameterTypes().length == 0) {
	Method setter = null;
	try {
	// Check if we have a setter
	setter = type.getDeclaredMethod("set"
	+ m.getName().substring(3), m.getReturnType());
	} catch (NoSuchMethodException ignoreit) {
	}
	String name = Introspector.decapitalize(m.getName()
	.substring(3));

	if (metadata.getProperty(name) == null) {
	// No previous property has been added with the same name
	metadata.addProperties(new PropertyMetadata(name, m
	.getReturnType(), m, setter));
	}
	}
	}
	}

	protected boolean isElementCollection(AccessibleObject ab) {
	return (ab.getAnnotation(ElementCollection.class) != null);
	}

	/**
	* Finds the actual pointed-to type of the field. The concrete type may be
	* other than the declared type if the targetEntity parameter is specified
	* in certain annotations.
	*
	* @param f
	* the field.
	* @return the type of the field.
	*/
	private Class<?> getFieldType(Field f) {
	Class<?> targetEntity = void.class;
	if (isReference(f)) {
	targetEntity = f.getAnnotation(ManyToOne.class).targetEntity();
	} else if (isOneToOne(f)) {
	targetEntity = f.getAnnotation(OneToOne.class).targetEntity();
	}
	if (targetEntity != void.class) {
	return targetEntity;
	}
	return f.getType();
	}

	private Class<?> convertPrimitiveType(Class<?> type) {
	// Vaadin fields don't work with primitive values, use wrapper types for
	// primitives
	if (type.isPrimitive()) {
	if (type.equals(Boolean.TYPE)) {
	type = Boolean.class;
	} else if (type.equals(Integer.TYPE)) {
	type = Integer.class;
	} else if (type.equals(Float.TYPE)) {
	type = Float.class;
	} else if (type.equals(Double.TYPE)) {
	type = Double.class;
	} else if (type.equals(Byte.TYPE)) {
	type = Byte.class;
	} else if (type.equals(Character.TYPE)) {
	type = Character.class;
	} else if (type.equals(Short.TYPE)) {
	type = Short.class;
	} else if (type.equals(Long.TYPE)) {
	type = Long.class;
	}
	}
	return type;
	}

	protected void extractPropertiesFromMethods(Class<?> type,
	ClassMetadata<?> metadata) {
	for (Method m : type.getDeclaredMethods()) {
	int mod = m.getModifiers();
	// Synthetic methods are excluded (#4590) - otherwise you could e.g.
	// have a synthetic and a concrete id getter (with different
	// declared return types) in TestClasses.Integer_ConcreteId_M, and
	// the synthetic method could override the concrete one and its
	// annotations.
	// In theory, this could filter out too much in some special cases,
	// in which case the subclass could re-declare the accessor methods
	// with the correct annotations as a workaround.
	if (m.getName().startsWith("get") && m.getName().length() > 3
	&& !Modifier.isStatic(mod) && !m.isSynthetic()
	&& m.getReturnType() != Void.TYPE
	&& m.getParameterTypes().length == 0) {
	Method setter = null;
	try {
	// Check if we have a setter
	setter = type.getDeclaredMethod("set"
	+ m.getName().substring(3), m.getReturnType());
	} catch (NoSuchMethodException ignoreit) {
	// No setter <=> transient property
	}
	String name = Introspector.decapitalize(m.getName()
	.substring(3));

	if (setter != null && m.getAnnotation(Transient.class) == null) {
	// Persistent property
	if (isEmbedded(m)) {
	ClassMetadata<?> cm = getClassMetadata(
	m.getReturnType(), AccessType.METHOD);
	metadata.addProperties(new PersistentPropertyMetadata(
	name, cm, PropertyKind.EMBEDDED, m, setter));
	} else if (isReference(m)) {
	ClassMetadata<?> cm = getClassMetadata(
	m.getReturnType(), AccessType.METHOD);
	metadata.addProperties(new PersistentPropertyMetadata(
	name, cm, PropertyKind.MANY_TO_ONE, m, setter));
	} else if (isOneToOne(m)) {
	ClassMetadata<?> cm = getClassMetadata(
	m.getReturnType(), AccessType.METHOD);
	metadata.addProperties(new PersistentPropertyMetadata(
	name, cm, PropertyKind.ONE_TO_ONE, m, setter));
	} else if (isCollection(m)) {
	metadata.addProperties(new PersistentPropertyMetadata(
	name, m.getReturnType(),
	PropertyKind.ONE_TO_MANY, m, setter));
	} else if (isManyToMany(m)) {
	metadata.addProperties(new PersistentPropertyMetadata(
	name, m.getReturnType(),
	PropertyKind.MANY_TO_MANY, m, setter));
	} else if (isElementCollection(m)) {
	metadata.addProperties(new PersistentPropertyMetadata(
	name, m.getReturnType(),
	PropertyKind.ELEMENT_COLLECTION, m, setter));
	} else {
	metadata.addProperties(new PersistentPropertyMetadata(
	name, m.getReturnType(), PropertyKind.SIMPLE,
	m, setter));
	}
	} else {
	// Transient property
	metadata.addProperties(new PropertyMetadata(name, m
	.getReturnType(), m, setter));
	}
	}
	}
	}
	}