public AnnotationReader buildAnnotationReader(AnnotatedElement annotatedElement) 
{
        return new JavaAnnotationReader(annotatedElement);
}

 public XClass classForName(String name,
    Class caller) throws ClassNotFoundException 
{
		return toXClass( ReflectHelper.classForName( name, caller ) );
}

 public boolean equals(XClass class1,
    Class class2) 
{
		if ( class1 == null ) {
			return class2 == null;
		}
		return ( (JavaXClass) class1 ).toClass().equals( class2 );
}

 public Map getDefaults() 
{
        return new HashMap();
}

 TypeEnvironment getTypeEnvironment(Type t) 
{
		return new TypeSwitch< TypeEnvironment >() {
			@Override
			public TypeEnvironment caseClass(Class classType) {
				return typeEnvs.getEnvironment( classType );
			}
			@Override
			public TypeEnvironment caseParameterizedType(ParameterizedType parameterizedType) {
				return typeEnvs.getEnvironment( parameterizedType );
			}
			@Override
			public TypeEnvironment defaultCase(Type type) {
				return IdentityTypeEnvironment.INSTANCE;
			}
		}.doSwitch( t );
}

 XPackage getXAnnotatedElement(Package pkg) 
{
		JavaXPackage xPackage = packagesToXPackages.get( pkg );
		if ( xPackage == null ) {
			xPackage = new JavaXPackage( pkg, this );
			packagesToXPackages.put( pkg, xPackage );
		}
		return xPackage;
}

 XMethod getXMethod(Member member,
    TypeEnvironment context) 
{
		MemberKey key = new MemberKey( member, context );
        //FIXME get is as expensive as create most time spent in hashCode and equals
        JavaXMethod xMethod = xMethods.get( key );
		if ( xMethod == null ) {
			xMethod = JavaXMethod.create( member, context, this );
			xMethods.put( key, xMethod );
		}
		return xMethod;
}

 XProperty getXProperty(Member member,
    TypeEnvironment context) 
{
		MemberKey key = new MemberKey( member, context );
        //FIXME get is as expensive as create most time spent in hashCode and equals
        JavaXProperty xProperty = xProperties.get( key );
		if ( xProperty == null ) {
			xProperty = JavaXProperty.create( member, context, this );
			xProperties.put( key, xProperty );
		}
		return xProperty;
}

 public XPackage packageForName(String packageName) throws ClassNotFoundException 
{
		return getXAnnotatedElement( ReflectHelper.classForName( packageName + ".package-info" ).getPackage() );
}

 public TypeEnvironment toApproximatingEnvironment(TypeEnvironment context) 
{
		return typeEnvs.toApproximatingEnvironment( context );
}

 public Class toClass(XClass xClazz) 
{
		if ( ! ( xClazz instanceof JavaXClass ) ) {
			throw new IllegalArgumentException( "XClass not coming from this ReflectionManager implementation" );
		}
		return (Class) ( (JavaXClass) xClazz ).toAnnotatedElement();
}

 public Method toMethod(XMethod xMethod) 
{
		if ( ! ( xMethod instanceof JavaXMethod ) ) {
			throw new IllegalArgumentException( "XMethod not coming from this ReflectionManager implementation" );
		}
		return (Method) ( (JavaXAnnotatedElement) xMethod ).toAnnotatedElement();
}

 public XClass toXClass(Class clazz) 
{
	    
		return toXClass( clazz, IdentityTypeEnvironment.INSTANCE );
}

 XClass toXClass(Type t,
    TypeEnvironment context) 
{
		return new TypeSwitch< XClass >() {
			@Override
			public XClass caseClass(Class classType) {
				TypeKey key = new TypeKey( classType, context );
				JavaXClass result = xClasses.get( key );
				if ( result == null ) {
					result = new JavaXClass( classType, context, JavaReflectionManager.this );
					xClasses.put( key, result );
				}
				return result;
			}
			@Override
			public XClass caseParameterizedType(ParameterizedType parameterizedType) {
				return toXClass( parameterizedType.getRawType(),
						typeEnvs.getEnvironment( parameterizedType, context )
				);
			}
		}.doSwitch( context.bind( t ) );
}

 public JavaXType toXType(TypeEnvironment context,
    Type propType) 
{
		Type boundType = toApproximatingEnvironment( context ).bind( propType );
		if ( TypeUtils.isArray( boundType ) ) {
			return new JavaXArrayType( propType, context, this );
		}
		if ( TypeUtils.isCollection( boundType ) ) {
			return new JavaXCollectionType( propType, context, this );
		}
		if ( TypeUtils.isSimple( boundType ) ) {
			return new JavaXSimpleType( propType, context, this );
		}
		throw new IllegalArgumentException( "No PropertyTypeExtractor available for type void " );
}