sun.reflect.generics.factory.GenericsFactory Maven / Gradle / Ivy
Show all versions of qbicc-rt-java.base Show documentation
/*
* 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.
*/
public interface GenericsFactory {
/**
* 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 {@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.
*
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 {@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
* {@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.
* @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 {@code byte}.
* @return the reflective representation of type {@code byte}.
*/
Type makeByte();
/**
* Returns the reflective representation of type {@code boolean}.
* @return the reflective representation of type {@code boolean}.
*/
Type makeBool();
/**
* Returns the reflective representation of type {@code short}.
* @return the reflective representation of type {@code short}.
*/
Type makeShort();
/**
* Returns the reflective representation of type {@code char}.
* @return the reflective representation of type {@code char}.
*/
Type makeChar();
/**
* Returns the reflective representation of type {@code int}.
* @return the reflective representation of type {@code int}.
*/
Type makeInt();
/**
* Returns the reflective representation of type {@code long}.
* @return the reflective representation of type {@code long}.
*/
Type makeLong();
/**
* Returns the reflective representation of type {@code float}.
* @return the reflective representation of type {@code float}.
*/
Type makeFloat();
/**
* Returns the reflective representation of type {@code double}.
* @return the reflective representation of type {@code double}.
*/
Type makeDouble();
/**
* Returns the reflective representation of {@code void}.
* @return the reflective representation of {@code void}.
*/
Type makeVoid();
}