https://openjdk.java.net/ 
/*
 * Copyright (c) 2003, 2006, 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.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.lang.reflect.WildcardType;
import sun.reflect.generics.tree.FieldTypeSignature;


A factory interface for reflective objects representing generic types.
Implementors (such as core reflection or JDI, or possibly javadoc
will manufacture instances of (potentially) different classes
in response to invocations of the methods described here.

 The intent is that reflective systems use these factories to
produce generic type information on demand.
Certain components of such reflective systems can be independent
of a specific implementation by using this interface. For example,
repositories of generic type information are initialized with a
factory conforming to this interface, and use it to generate the
type information they are required to provide. As a result, such
repository code can be shared across different reflective systems.

/**
 * A factory interface for reflective objects representing generic types.
 * Implementors (such as core reflection or JDI, or possibly javadoc
 * will manufacture instances of (potentially) different classes
 * in response to invocations of the methods described here.
 * <p> The intent is that reflective systems use these factories to
 * produce generic type information on demand.
 * Certain components of such reflective systems can be independent
 * of a specific implementation by using this interface. For example,
 * repositories of generic type information are initialized with a
 * factory conforming to this interface, and use it to generate the
 * type information they are required to provide. As a result, such
 * repository code can be shared across different reflective systems.
 */
public interface GenericsFactory {
    
Returns a new type variable declaration. Note that name may be empty (but not null). If bounds is empty, a bound of java.lang.Object is used. 
Params:
  • name – The name of the type variable
  • bounds – An array of abstract syntax trees representing
the upper bound(s) on the type variable being declared
Throws:
Returns:a new type variable declaration
/**
     * Returns a new type variable declaration. Note that {@code name}
     * may be empty (but not {@code null}). If {@code bounds} is
     * empty, a bound of {@code java.lang.Object} is used.
     * @param name The name of the type variable
     * @param bounds An array of abstract syntax trees representing
     * the upper bound(s) on the type variable being declared
     * @return a new type variable declaration
     * @throws NullPointerException if any of the actual parameters
     * or any of the elements of {@code bounds} are {@code null}.
     */
    TypeVariable<?> makeTypeVariable(String name,
                                     FieldTypeSignature[] bounds);
    
Returns an instance of the ParameterizedType interface that corresponds to a generic type instantiation of the generic declaration declaration with actual type arguments typeArgs. If owner is null, the declaring class of declaration is used as the owner of this parameterized type. 
 This method throws a MalformedParameterizedTypeException under the following circumstances: If the type declaration does not represent a generic declaration (i.e., it is not an instance of GenericDeclaration). If the number of actual type arguments (i.e., the size of the array typeArgs) does not correspond to the number of formal type arguments. If any of the actual type arguments is not an instance of the bounds on the corresponding formal. 
Params:
  • declaration – - the generic type declaration that is to be
instantiated
  • typeArgs – - the list of actual type arguments
Throws:
  • MalformedParameterizedTypeException – if the instantiation
is invalid
  • NullPointerException – if any of declaration, typeArgs or any of the elements of typeArgs are null
Returns:- a parameterized type representing the instantiation
of the declaration with the actual type arguments
/**
     * Returns an instance of the {@code ParameterizedType} interface
     * that corresponds to a generic type instantiation of the
     * generic declaration {@code declaration} with actual type arguments
     * {@code typeArgs}.
     * If {@code owner} is {@code null}, the declaring class of
     * {@code declaration} is used as the owner of this parameterized
     * type.
     * <p> This method throws a MalformedParameterizedTypeException
     * under the following circumstances:
     * If the type declaration does not represent a generic declaration
     * (i.e., it is not an instance of {@code GenericDeclaration}).
     * If the number of actual type arguments (i.e., the size of the
     * array {@code typeArgs}) does not correspond to the number of
     * formal type arguments.
     * If any of the actual type arguments is not an instance of the
     * bounds on the corresponding formal.
     * @param declaration - the generic type declaration that is to be
     * instantiated
     * @param typeArgs - the list of actual type arguments
     * @return - a parameterized type representing the instantiation
     * of the declaration with the actual type arguments
     * @throws MalformedParameterizedTypeException if the instantiation
     * is invalid
     * @throws NullPointerException if any of {@code declaration},
     * {@code typeArgs}
     * or any of the elements of {@code typeArgs} are {@code null}
     */
    ParameterizedType makeParameterizedType(Type declaration,
                                            Type[] typeArgs,
                                            Type owner);

    
Returns the type variable with name name, if such a type variable is declared in the scope used to create this factory. Returns null otherwise. 
Params:
  • name – - the name of the type variable to search for
Throws:
Returns:- the type variable with name name, or null
/**
     * Returns the type variable with name {@code name}, if such
     * a type variable is declared in the
     * scope used to create this factory.
     * Returns {@code null} otherwise.
     * @param name - the name of the type variable to search for
     * @return - the type variable with name {@code name}, or {@code null}
     * @throws  NullPointerException if any of actual parameters are
     * {@code null}
     */
    TypeVariable<?> findTypeVariable(String name);

    
Returns a new wildcard type variable. If ubs is empty, a bound of java.lang.Object is used. 
Params:
  • ubs – An array of abstract syntax trees representing
the upper bound(s) on the type variable being declared
  • lbs – An array of abstract syntax trees representing
the lower bound(s) on the type variable being declared
Throws:
  • NullPointerException – if any of the actual parameters or any of the elements of ubs or lbs are null
Returns:a new wildcard type variable
/**
     * Returns a new wildcard type variable. If
     * {@code ubs} is empty, a bound of {@code java.lang.Object} is used.
     * @param ubs An array of abstract syntax trees representing
     * the upper bound(s) on the type variable being declared
     * @param lbs An array of abstract syntax trees representing
     * the lower bound(s) on the type variable being declared
     * @return a new wildcard type variable
     * @throws NullPointerException if any of the actual parameters
     * or any of the elements of {@code ubs} or {@code lbs} are
     * {@code null}
     */
    WildcardType makeWildcard(FieldTypeSignature[] ubs,
                              FieldTypeSignature[] lbs);

    Type makeNamedType(String name);

    
Returns a (possibly generic) array type.
If the component type is a parameterized type, it must
only have unbounded wildcard arguments, otherwise
a MalformedParameterizedTypeException is thrown.

Params:
  • componentType – - the component type of the array
Throws:
  • MalformedParameterizedTypeException – if componentType is a parameterized type with non-wildcard type arguments
  • NullPointerException – if any of the actual parameters are null
Returns:a (possibly generic) array type.
/**
     * Returns a (possibly generic) array type.
     * If the component type is a parameterized type, it must
     * only have unbounded wildcard arguments, otherwise
     * a MalformedParameterizedTypeException is thrown.
     * @param componentType - the component type of the array
     * @return a (possibly generic) array type.
     * @throws MalformedParameterizedTypeException if {@code componentType}
     * is a parameterized type with non-wildcard type arguments
     * @throws NullPointerException if any of the actual parameters
     * are {@code null}
     */
    Type makeArrayType(Type componentType);

    
Returns the reflective representation of type byte. 
Returns:the reflective representation of type byte.
/**
     * Returns the reflective representation of type {@code byte}.
     * @return the reflective representation of type {@code byte}.
     */
    Type makeByte();

    
Returns the reflective representation of type boolean. 
Returns:the reflective representation of type boolean.
/**
     * Returns the reflective representation of type {@code boolean}.
     * @return the reflective representation of type {@code boolean}.
     */
    Type makeBool();

    
Returns the reflective representation of type short. 
Returns:the reflective representation of type short.
/**
     * Returns the reflective representation of type {@code short}.
     * @return the reflective representation of type {@code short}.
     */
    Type makeShort();

    
Returns the reflective representation of type char. 
Returns:the reflective representation of type char.
/**
     * Returns the reflective representation of type {@code char}.
     * @return the reflective representation of type {@code char}.
     */
    Type makeChar();

    
Returns the reflective representation of type int. 
Returns:the reflective representation of type int.
/**
     * Returns the reflective representation of type {@code int}.
     * @return the reflective representation of type {@code int}.
     */
    Type makeInt();

    
Returns the reflective representation of type long. 
Returns:the reflective representation of type long.
/**
     * Returns the reflective representation of type {@code long}.
     * @return the reflective representation of type {@code long}.
     */
    Type makeLong();

    
Returns the reflective representation of type float. 
Returns:the reflective representation of type float.
/**
     * Returns the reflective representation of type {@code float}.
     * @return the reflective representation of type {@code float}.
     */
    Type makeFloat();

    
Returns the reflective representation of type double. 
Returns:the reflective representation of type double.
/**
     * Returns the reflective representation of type {@code double}.
     * @return the reflective representation of type {@code double}.
     */
    Type makeDouble();

    
Returns the reflective representation of void. 
Returns:the reflective representation of void.
/**
     * Returns the reflective representation of {@code void}.
     * @return the reflective representation of {@code void}.
     */
    Type makeVoid();
}