/*
 * Copyright (c) 2003, 2008, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package sun.reflect.generics.factory;

import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.GenericDeclaration;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.lang.reflect.WildcardType;


import sun.reflect.generics.reflectiveObjects.*;
import sun.reflect.generics.scope.Scope;
import sun.reflect.generics.tree.FieldTypeSignature;


Factory for reflective generic type objects for use by core reflection (java.lang.reflect).
/** * Factory for reflective generic type objects for use by * core reflection (java.lang.reflect). */
public class CoreReflectionFactory implements GenericsFactory { private final GenericDeclaration decl; private final Scope scope; private CoreReflectionFactory(GenericDeclaration d, Scope s) { decl = d; scope = s; } private GenericDeclaration getDecl(){ return decl;} private Scope getScope(){ return scope;} private ClassLoader getDeclsLoader() { if (decl instanceof Class) {return ((Class) decl).getClassLoader();} if (decl instanceof Method) { return ((Method) decl).getDeclaringClass().getClassLoader(); } assert decl instanceof Constructor : "Constructor expected"; return ((Constructor) decl).getDeclaringClass().getClassLoader(); }
Factory for this class. Returns an instance of CoreReflectionFactory for the declaration and scope provided. This factory will produce reflective objects of the appropriate kind. Classes produced will be those that would be loaded by the defining class loader of the declaration d (if d is a type declaration, or by the defining loader of the declaring class of d otherwise.

Type variables will be created or lookup as necessary in the scope s.

Params:
  • d – - the generic declaration (class, interface, method or constructor) that thsi factory services
  • s – the scope in which the factory will allocate and search for type variables
Returns:an instance of CoreReflectionFactory
/** * Factory for this class. Returns an instance of * <tt>CoreReflectionFactory</tt> for the declaration and scope * provided. * This factory will produce reflective objects of the appropriate * kind. Classes produced will be those that would be loaded by the * defining class loader of the declaration <tt>d</tt> (if <tt>d</tt> * is a type declaration, or by the defining loader of the declaring * class of <tt>d</tt> otherwise. * <p> Type variables will be created or lookup as necessary in the * scope <tt> s</tt>. * @param d - the generic declaration (class, interface, method or * constructor) that thsi factory services * @param s the scope in which the factory will allocate and search for * type variables * @return an instance of <tt>CoreReflectionFactory</tt> */
public static CoreReflectionFactory make(GenericDeclaration d, Scope s) { return new CoreReflectionFactory(d, s); } public TypeVariable<?> makeTypeVariable(String name, FieldTypeSignature[] bounds){ return TypeVariableImpl.make(getDecl(), name, bounds, this); } public WildcardType makeWildcard(FieldTypeSignature[] ubs, FieldTypeSignature[] lbs) { return WildcardTypeImpl.make(ubs, lbs, this); } public ParameterizedType makeParameterizedType(Type declaration, Type[] typeArgs, Type owner) { return ParameterizedTypeImpl.make((Class<?>) declaration, typeArgs, owner); } public TypeVariable<?> findTypeVariable(String name){ return getScope().lookup(name); } public Type makeNamedType(String name){ try {return Class.forName(name, false, // don't initialize getDeclsLoader());} catch (ClassNotFoundException c) { throw new TypeNotPresentException(name, c); } } public Type makeArrayType(Type componentType){ if (componentType instanceof Class<?>) return Array.newInstance((Class<?>) componentType, 0).getClass(); else return GenericArrayTypeImpl.make(componentType); } public Type makeByte(){return byte.class;} public Type makeBool(){return boolean.class;} public Type makeShort(){return short.class;} public Type makeChar(){return char.class;} public Type makeInt(){return int.class;} public Type makeLong(){return long.class;} public Type makeFloat(){return float.class;} public Type makeDouble(){return double.class;} public Type makeVoid(){return void.class;} }