gistfile1.txt

package org.hibernate.metamodel.internal.source.annotations.attribute;

import java.util.Collection;
import java.util.List;
import java.util.Map;

import com.fasterxml.classmate.MemberResolver;
import com.fasterxml.classmate.ResolvedType;
import com.fasterxml.classmate.ResolvedTypeWithMembers;
import com.fasterxml.classmate.TypeResolver;
import com.fasterxml.classmate.members.ResolvedField;

/**
 * @author Strong Liu <[email protected]>
 */
public class ClassmateTest {
  private static TypeResolver typeResolver = new TypeResolver(); // TypeResolvers are thread-safe, reusable

	private static ResolvedTypeWithMembers resolveEmbeddableMembers(Class clazz, List<ResolvedType> resolvedTypes) {
		for ( ResolvedType type : resolvedTypes ) {
			ResolvedTypeWithMembers members = resolveEmbeddableMembers( clazz, type );
			if ( members != null ) {
				return members;
			}
		}
		return null;
	}

	/**
	 * An embeddable class maybe generic, the actual parameter types are resolved from field/property defined in the entity class.
	 *
	 * @param clazz The embeddable class to be resolved.
	 * @param resolvedType The embedded attribute resolved type.
	 *
	 * @return
	 */
	private static ResolvedTypeWithMembers resolveEmbeddableMembers(Class clazz, ResolvedType resolvedType) {

		boolean canCreateSubtype = resolvedType.canCreateSubtype( clazz );
		if ( canCreateSubtype ) {
			ResolvedType pojoType = typeResolver.resolve(
					clazz,
					resolvedType.getTypeParameters().toArray( new ResolvedType[0] )
			);
			MemberResolver memberResolver = new MemberResolver( typeResolver ); // likewise, reusable
			return memberResolver.resolve( pojoType, null, null );
		}
		else if ( resolvedType.isArray() ) {
			return resolveEmbeddableMembers( clazz, resolvedType.getArrayElementType() );

		}
		else if ( resolvedType.isInstanceOf( Collection.class ) ) {
			return resolveEmbeddableMembers( clazz, resolvedType.getTypeParameters() );

		}
		else if ( resolvedType.isInstanceOf( Map.class ) ) {
			return resolveEmbeddableMembers( clazz, resolvedType.getTypeParameters() );

		}
		return null;
	}

	private static void print(ResolvedTypeWithMembers members) {
		if ( members == null ) {
			return;
		}
		for ( ResolvedField field : members.getMemberFields() ) {
			System.out.println(field.getType()+" " + field.getName());
//			System.out.println( "Field is : " + field.getName() );
//			System.out.println( "Type is: " + field.getType() );
		}
	}


	public static void main(String[] args) {
		ResolvedType pojoType = typeResolver.resolve( Entity.class );
		MemberResolver memberResolver = new MemberResolver( typeResolver ); // likewise, reusable
		ResolvedTypeWithMembers bean = memberResolver.resolve( pojoType, null, null );
		for ( ResolvedField field : bean.getMemberFields() ) {
			ResolvedType resolvedType = field.getType();
			ResolvedTypeWithMembers members = resolveEmbeddableMembers( Embeddable.class, resolvedType );
			System.out.println("-------------------------------------- " + field.getName());
			print( members );
		}
	}

	public static class Embeddable<T, S> {
		public T t;
		public S s;
	}

	public static class Entity {
		Embeddable<String, Integer> embeddable;

		List<Embeddable<Long, Integer>> embeddableList;

		Embeddable<String, Integer>[] embeddableArray;

		Map<String, Embeddable<String, Integer>> embeddableMap;
	}
}