399 lines
13 KiB
Java
399 lines
13 KiB
Java
/* java.lang.reflect.Constructor - reflection of Java constructors
|
|
Copyright (C) 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006
|
|
Free Software Foundation, Inc.
|
|
|
|
This file is part of GNU Classpath.
|
|
|
|
GNU Classpath is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
any later version.
|
|
|
|
GNU Classpath 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 for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GNU Classpath; see the file COPYING. If not, write to the
|
|
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
02110-1301 USA.
|
|
|
|
Linking this library statically or dynamically with other modules is
|
|
making a combined work based on this library. Thus, the terms and
|
|
conditions of the GNU General Public License cover the whole
|
|
combination.
|
|
|
|
As a special exception, the copyright holders of this library give you
|
|
permission to link this library with independent modules to produce an
|
|
executable, regardless of the license terms of these independent
|
|
modules, and to copy and distribute the resulting executable under
|
|
terms of your choice, provided that you also meet, for each linked
|
|
independent module, the terms and conditions of the license of that
|
|
module. An independent module is a module which is not derived from
|
|
or based on this library. If you modify this library, you may extend
|
|
this exception to your version of the library, but you are not
|
|
obligated to do so. If you do not wish to do so, delete this
|
|
exception statement from your version. */
|
|
|
|
|
|
package java.lang.reflect;
|
|
|
|
import gnu.java.lang.reflect.MethodSignatureParser;
|
|
|
|
/**
|
|
* The Constructor class represents a constructor of a class. It also allows
|
|
* dynamic creation of an object, via reflection. Invocation on Constructor
|
|
* objects knows how to do widening conversions, but throws
|
|
* {@link IllegalArgumentException} if a narrowing conversion would be
|
|
* necessary. You can query for information on this Constructor regardless
|
|
* of location, but construction access may be limited by Java language
|
|
* access controls. If you can't do it in the compiler, you can't normally
|
|
* do it here either.<p>
|
|
*
|
|
* <B>Note:</B> This class returns and accepts types as Classes, even
|
|
* primitive types; there are Class types defined that represent each
|
|
* different primitive type. They are <code>java.lang.Boolean.TYPE,
|
|
* java.lang.Byte.TYPE,</code>, also available as <code>boolean.class,
|
|
* byte.class</code>, etc. These are not to be confused with the
|
|
* classes <code>java.lang.Boolean, java.lang.Byte</code>, etc., which are
|
|
* real classes.<p>
|
|
*
|
|
* Also note that this is not a serializable class. It is entirely feasible
|
|
* to make it serializable using the Externalizable interface, but this is
|
|
* on Sun, not me.
|
|
*
|
|
* @author John Keiser
|
|
* @author Eric Blake <ebb9@email.byu.edu>
|
|
* @author Tom Tromey <tromey@redhat.com>
|
|
* @see Member
|
|
* @see Class
|
|
* @see java.lang.Class#getConstructor(Class[])
|
|
* @see java.lang.Class#getDeclaredConstructor(Class[])
|
|
* @see java.lang.Class#getConstructors()
|
|
* @see java.lang.Class#getDeclaredConstructors()
|
|
* @since 1.1
|
|
* @status updated to 1.4
|
|
*/
|
|
public final class Constructor extends AccessibleObject
|
|
implements Member, GenericDeclaration
|
|
{
|
|
private static final int CONSTRUCTOR_MODIFIERS
|
|
= Modifier.PRIVATE | Modifier.PROTECTED | Modifier.PUBLIC;
|
|
|
|
/**
|
|
* This class is uninstantiable except from native code.
|
|
*/
|
|
private Constructor ()
|
|
{
|
|
}
|
|
|
|
/**
|
|
* Gets the class that declared this constructor.
|
|
* @return the class that declared this member
|
|
*/
|
|
public Class getDeclaringClass()
|
|
{
|
|
return declaringClass;
|
|
}
|
|
|
|
/**
|
|
* Gets the name of this constructor (the non-qualified name of the class
|
|
* it was declared in).
|
|
* @return the name of this constructor
|
|
*/
|
|
public String getName()
|
|
{
|
|
return declaringClass.getName();
|
|
}
|
|
|
|
/**
|
|
* Return the raw modifiers for this constructor. In particular
|
|
* this will include the synthetic and varargs bits.
|
|
* @return the constructor's modifiers
|
|
*/
|
|
private native int getModifiersInternal();
|
|
|
|
/**
|
|
* Gets the modifiers this constructor uses. Use the <code>Modifier</code>
|
|
* class to interpret the values. A constructor can only have a subset of the
|
|
* following modifiers: public, private, protected.
|
|
*
|
|
* @return an integer representing the modifiers to this Member
|
|
* @see Modifier
|
|
*/
|
|
public int getModifiers ()
|
|
{
|
|
return getModifiersInternal() & CONSTRUCTOR_MODIFIERS;
|
|
}
|
|
|
|
/**
|
|
* Return true if this constructor is synthetic, false otherwise.
|
|
* A synthetic member is one which is created by the compiler,
|
|
* and which does not appear in the user's source code.
|
|
* @since 1.5
|
|
*/
|
|
public boolean isSynthetic()
|
|
{
|
|
return (getModifiersInternal() & Modifier.SYNTHETIC) != 0;
|
|
}
|
|
|
|
/**
|
|
* Return true if this is a varargs constructor, that is if
|
|
* the constructor takes a variable number of arguments.
|
|
* @since 1.5
|
|
*/
|
|
public boolean isVarArgs()
|
|
{
|
|
return (getModifiersInternal() & Modifier.VARARGS) != 0;
|
|
}
|
|
|
|
/**
|
|
* Get the parameter list for this constructor, in declaration order. If the
|
|
* constructor takes no parameters, returns a 0-length array (not null).
|
|
*
|
|
* @return a list of the types of the constructor's parameters
|
|
*/
|
|
public Class[] getParameterTypes ()
|
|
{
|
|
if (parameter_types == null)
|
|
getType ();
|
|
return (Class[]) parameter_types.clone();
|
|
}
|
|
|
|
/**
|
|
* Get the exception types this constructor says it throws, in no particular
|
|
* order. If the constructor has no throws clause, returns a 0-length array
|
|
* (not null).
|
|
*
|
|
* @return a list of the types in the constructor's throws clause
|
|
*/
|
|
public Class[] getExceptionTypes ()
|
|
{
|
|
if (exception_types == null)
|
|
getType();
|
|
return (Class[]) exception_types.clone();
|
|
}
|
|
|
|
/**
|
|
* Compare two objects to see if they are semantically equivalent.
|
|
* Two Constructors are semantically equivalent if they have the same
|
|
* declaring class and the same parameter list.
|
|
*
|
|
* @param o the object to compare to
|
|
* @return <code>true</code> if they are equal; <code>false</code> if not.
|
|
*/
|
|
public boolean equals (Object obj)
|
|
{
|
|
if (! (obj instanceof Constructor))
|
|
return false;
|
|
Constructor c = (Constructor) obj;
|
|
return declaringClass == c.declaringClass && offset == c.offset;
|
|
}
|
|
|
|
/**
|
|
* Get the hash code for the Constructor. The Constructor hash code is the
|
|
* hash code of the declaring class's name.
|
|
*
|
|
* @return the hash code for the object
|
|
*/
|
|
public int hashCode ()
|
|
{
|
|
return declaringClass.getName().hashCode();
|
|
}
|
|
|
|
/**
|
|
* Get a String representation of the Constructor. A Constructor's String
|
|
* representation is "<modifier> <classname>(<paramtypes>)
|
|
* throws <exceptions>", where everything after ')' is omitted if
|
|
* there are no exceptions.<br> Example:
|
|
* <code>public java.io.FileInputStream(java.lang.Runnable)
|
|
* throws java.io.FileNotFoundException</code>
|
|
*
|
|
* @return the String representation of the Constructor
|
|
*/
|
|
public String toString()
|
|
{
|
|
if (parameter_types == null)
|
|
getType ();
|
|
StringBuffer b = new StringBuffer ();
|
|
int mods = getModifiers();
|
|
if (mods != 0)
|
|
{
|
|
Modifier.toString(mods, b);
|
|
b.append(" ");
|
|
}
|
|
Method.appendClassName (b, declaringClass);
|
|
b.append("(");
|
|
for (int i = 0; i < parameter_types.length; ++i)
|
|
{
|
|
Method.appendClassName (b, parameter_types[i]);
|
|
if (i < parameter_types.length - 1)
|
|
b.append(",");
|
|
}
|
|
b.append(")");
|
|
return b.toString();
|
|
}
|
|
|
|
/* FIXME[GENERICS]: Add X extends GenericDeclaration and TypeVariable<X> */
|
|
static void addTypeParameters(StringBuilder sb, TypeVariable[] typeArgs)
|
|
{
|
|
if (typeArgs.length == 0)
|
|
return;
|
|
sb.append('<');
|
|
for (int i = 0; i < typeArgs.length; ++i)
|
|
{
|
|
if (i > 0)
|
|
sb.append(',');
|
|
sb.append(typeArgs[i]);
|
|
}
|
|
sb.append("> ");
|
|
}
|
|
|
|
public String toGenericString()
|
|
{
|
|
StringBuilder sb = new StringBuilder(128);
|
|
Modifier.toString(getModifiers(), sb).append(' ');
|
|
addTypeParameters(sb, getTypeParameters());
|
|
sb.append(getDeclaringClass().getName()).append('(');
|
|
Type[] types = getGenericParameterTypes();
|
|
if (types.length > 0)
|
|
{
|
|
sb.append(types[0]);
|
|
for (int i = 1; i < types.length; ++i)
|
|
sb.append(',').append(types[i]);
|
|
}
|
|
sb.append(')');
|
|
types = getGenericExceptionTypes();
|
|
if (types.length > 0)
|
|
{
|
|
sb.append(" throws ").append(types[0]);
|
|
for (int i = 1; i < types.length; i++)
|
|
sb.append(',').append(types[i]);
|
|
}
|
|
return sb.toString();
|
|
}
|
|
|
|
/**
|
|
* Create a new instance by invoking the constructor. Arguments are
|
|
* automatically unwrapped and widened, if needed.<p>
|
|
*
|
|
* If this class is abstract, you will get an
|
|
* <code>InstantiationException</code>. If the constructor takes 0
|
|
* arguments, you may use null or a 0-length array for <code>args</code>.<p>
|
|
*
|
|
* If this Constructor enforces access control, your runtime context is
|
|
* evaluated, and you may have an <code>IllegalAccessException</code> if
|
|
* you could not create this object in similar compiled code. If the class
|
|
* is uninitialized, you trigger class initialization, which may end in a
|
|
* <code>ExceptionInInitializerError</code>.<p>
|
|
*
|
|
* Then, the constructor is invoked. If it completes normally, the return
|
|
* value will be the new object. If it completes abruptly, the exception is
|
|
* wrapped in an <code>InvocationTargetException</code>.
|
|
*
|
|
* @param args the arguments to the constructor
|
|
* @return the newly created object
|
|
* @throws IllegalAccessException if the constructor could not normally be
|
|
* called by the Java code (i.e. it is not public)
|
|
* @throws IllegalArgumentException if the number of arguments is incorrect;
|
|
* or if the arguments types are wrong even with a widening
|
|
* conversion
|
|
* @throws InstantiationException if the class is abstract
|
|
* @throws InvocationTargetException if the constructor throws an exception
|
|
* @throws ExceptionInInitializerError if construction triggered class
|
|
* initialization, which then failed
|
|
*/
|
|
public native Object newInstance (Object[] args)
|
|
throws InstantiationException, IllegalAccessException,
|
|
IllegalArgumentException, InvocationTargetException;
|
|
|
|
/**
|
|
* Returns an array of <code>TypeVariable</code> objects that represents
|
|
* the type variables declared by this constructor, in declaration order.
|
|
* An array of size zero is returned if this constructor has no type
|
|
* variables.
|
|
*
|
|
* @return the type variables associated with this constructor.
|
|
* @throws GenericSignatureFormatError if the generic signature does
|
|
* not conform to the format specified in the Virtual Machine
|
|
* specification, version 3.
|
|
* @since 1.5
|
|
*/
|
|
/* FIXME[GENERICS]: Add <Constructor<T>> */
|
|
public TypeVariable[] getTypeParameters()
|
|
{
|
|
String sig = getSignature();
|
|
if (sig == null)
|
|
return new TypeVariable[0];
|
|
MethodSignatureParser p = new MethodSignatureParser(this, sig);
|
|
return p.getTypeParameters();
|
|
}
|
|
|
|
/**
|
|
* Return the String in the Signature attribute for this constructor. If there
|
|
* is no Signature attribute, return null.
|
|
*/
|
|
private String getSignature()
|
|
{
|
|
// FIXME: libgcj doesn't record this information yet.
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Returns an array of <code>Type</code> objects that represents
|
|
* the exception types declared by this constructor, in declaration order.
|
|
* An array of size zero is returned if this constructor declares no
|
|
* exceptions.
|
|
*
|
|
* @return the exception types declared by this constructor.
|
|
* @throws GenericSignatureFormatError if the generic signature does
|
|
* not conform to the format specified in the Virtual Machine
|
|
* specification, version 3.
|
|
* @since 1.5
|
|
*/
|
|
public Type[] getGenericExceptionTypes()
|
|
{
|
|
String sig = getSignature();
|
|
if (sig == null)
|
|
return getExceptionTypes();
|
|
MethodSignatureParser p = new MethodSignatureParser(this, sig);
|
|
return p.getGenericExceptionTypes();
|
|
}
|
|
|
|
/**
|
|
* Returns an array of <code>Type</code> objects that represents
|
|
* the parameter list for this constructor, in declaration order.
|
|
* An array of size zero is returned if this constructor takes no
|
|
* parameters.
|
|
*
|
|
* @return a list of the types of the constructor's parameters
|
|
* @throws GenericSignatureFormatError if the generic signature does
|
|
* not conform to the format specified in the Virtual Machine
|
|
* specification, version 3.
|
|
* @since 1.5
|
|
*/
|
|
public Type[] getGenericParameterTypes()
|
|
{
|
|
String sig = getSignature();
|
|
if (sig == null)
|
|
return getParameterTypes();
|
|
MethodSignatureParser p = new MethodSignatureParser(this, sig);
|
|
return p.getGenericParameterTypes();
|
|
}
|
|
|
|
// Update cached values from method descriptor in class.
|
|
private native void getType ();
|
|
|
|
// Declaring class.
|
|
private Class declaringClass;
|
|
|
|
// Exception types.
|
|
private Class[] exception_types;
|
|
// Parameter types.
|
|
private Class[] parameter_types;
|
|
|
|
// Offset in bytes from the start of declaringClass's methods array.
|
|
private int offset;
|
|
}
|