Java example source code file (GenericsFactory.java)

This example Java source code file (GenericsFactory.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

fieldtypesignature, genericsfactory, parameterizedtype, reflection, type, typevariable, wildcardtype

The GenericsFactory.java Java example source code

/*
 * 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.
 * <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
 * tpe 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 <tt>name
     * may be empty (but not <tt>null). If bounds is
     * empty, a bound of <tt>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 <tt>bounds are null.
     */
    TypeVariable<?> makeTypeVariable(String name,
                                     FieldTypeSignature[] bounds);
    /**
     * Return an instance of the <tt>ParameterizedType interface
     * that corresponds to a generic type instantiation of the
     * generic declaration <tt>declaration with actual type arguments
     * <tt>typeArgs.
     * If <tt>owner is null, the declaring class of
     * <tt>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 <tt>GenericDeclaration).
     * If the number of actual type arguments (i.e., the size of the
     * array <tt>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 <tt>declaration
     * , <tt>typeArgs
     * or any of the elements of <tt>typeArgs are null
     */
    ParameterizedType makeParameterizedType(Type declaration,
                                            Type[] typeArgs,
                                            Type owner);

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

    /**
     * Returns a new wildcard type variable. If
     * <tt>ubs is empty, a bound of 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 <tt>ubs or lbsare
     * <tt>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 arguemnts, otherwise
     * a MalformedParameterizedTypeException is thrown.
     * @param componentType - the component type of the array
     * @return a (possibly generic) array type.
     * @throws MalformedParameterizedTypeException if <tt>componentType
     * is a parameterized type with non-wildcard type arguments
     * @throws NullPointerException - if any of the actual parameters
     * are <tt>null
     */
    Type makeArrayType(Type componentType);

    /**
     * Returns the reflective representation of type <tt>byte.
     * @return the reflective representation of type <tt>byte.
     */
    Type makeByte();

    /**
     * Returns the reflective representation of type <tt>boolean.
     * @return the reflective representation of type <tt>boolean.
     */
    Type makeBool();

    /**
     * Returns the reflective representation of type <tt>short.
     * @return the reflective representation of type <tt>short.
     */
    Type makeShort();

    /**
     * Returns the reflective representation of type <tt>char.
     * @return the reflective representation of type <tt>char.
     */
    Type makeChar();

    /**
     * Returns the reflective representation of type <tt>int.
     * @return the reflective representation of type <tt>int.
     */
    Type makeInt();

    /**
     * Returns the reflective representation of type <tt>long.
     * @return the reflective representation of type <tt>long.
     */
    Type makeLong();

    /**
     * Returns the reflective representation of type <tt>float.
     * @return the reflective representation of type <tt>float.
     */
    Type makeFloat();

    /**
     * Returns the reflective representation of type <tt>double.
     * @return the reflective representation of type <tt>double.
     */
    Type makeDouble();

    /**
     * Returns the reflective representation of <tt>void.
     * @return the reflective representation of <tt>void.
     */
    Type makeVoid();
}