org.hibernate.bytecode.internal.javassist.FastClass Maven / Gradle / Ivy
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or .
*/
package org.hibernate.bytecode.internal.javassist;
import java.io.Serializable;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
/**
* Fast access to class information
*
* @author Muga Nishizawa
*/
public class FastClass implements Serializable {
private static final Class[] EMPTY_CLASS_ARRAY = new Class[0];
private final Class type;
/**
* Constructs a FastClass
*
* @param type The class to optimize
*
* @return The fast class access to the given class
*/
public static FastClass create(Class type) {
return new FastClass( type );
}
private FastClass(Class type) {
this.type = type;
}
/**
* Access to invoke a method on the class that this fast class handles
*
* @param name The name of the method to invoke,
* @param parameterTypes The method parameter types
* @param obj The instance on which to invoke the method
* @param args The parameter arguments
*
* @return The method result
*
* @throws InvocationTargetException Indicates a problem performing invocation
*/
public Object invoke(
String name,
Class[] parameterTypes,
Object obj,
Object[] args) throws InvocationTargetException {
return this.invoke( this.getIndex( name, parameterTypes ), obj, args );
}
/**
* Access to invoke a method on the class that this fast class handles by its index
*
* @param index The method index
* @param obj The instance on which to invoke the method
* @param args The parameter arguments
*
* @return The method result
*
* @throws InvocationTargetException Indicates a problem performing invocation
*/
public Object invoke(
int index,
Object obj,
Object[] args) throws InvocationTargetException {
final Method[] methods = this.type.getMethods();
try {
return methods[index].invoke( obj, args );
}
catch ( ArrayIndexOutOfBoundsException e ) {
throw new IllegalArgumentException(
"Cannot find matching method/constructor"
);
}
catch ( IllegalAccessException e ) {
throw new InvocationTargetException( e );
}
}
/**
* Invoke the default constructor
*
* @return The constructed instance
*
* @throws InvocationTargetException Indicates a problem performing invocation
*/
public Object newInstance() throws InvocationTargetException {
return this.newInstance( this.getIndex( EMPTY_CLASS_ARRAY ), null );
}
/**
* Invoke a parameterized constructor
*
* @param parameterTypes The parameter types
* @param args The parameter arguments to pass along
*
* @return The constructed instance
*
* @throws InvocationTargetException Indicates a problem performing invocation
*/
public Object newInstance(
Class[] parameterTypes,
Object[] args) throws InvocationTargetException {
return this.newInstance( this.getIndex( parameterTypes ), args );
}
/**
* Invoke a constructor by its index
*
* @param index The constructor index
* @param args The parameter arguments to pass along
*
* @return The constructed instance
*
* @throws InvocationTargetException Indicates a problem performing invocation
*/
public Object newInstance(
int index,
Object[] args) throws InvocationTargetException {
final Constructor[] constructors = this.type.getConstructors();
try {
return constructors[index].newInstance( args );
}
catch ( ArrayIndexOutOfBoundsException e ) {
throw new IllegalArgumentException( "Cannot find matching method/constructor" );
}
catch ( InstantiationException e ) {
throw new InvocationTargetException( e );
}
catch ( IllegalAccessException e ) {
throw new InvocationTargetException( e );
}
}
/**
* Locate the index of a method
*
* @param name The method name
* @param parameterTypes The method parameter types
*
* @return The index
*/
public int getIndex(String name, Class[] parameterTypes) {
final Method[] methods = this.type.getMethods();
boolean eq;
for ( int i = 0; i < methods.length; ++i ) {
if ( !Modifier.isPublic( methods[i].getModifiers() ) ) {
continue;
}
if ( !methods[i].getName().equals( name ) ) {
continue;
}
final Class[] params = methods[i].getParameterTypes();
if ( params.length != parameterTypes.length ) {
continue;
}
eq = true;
for ( int j = 0; j < params.length; ++j ) {
if ( !params[j].equals( parameterTypes[j] ) ) {
eq = false;
break;
}
}
if ( eq ) {
return i;
}
}
return -1;
}
/**
* Locate the index of a constructor
*
* @param parameterTypes The constructor parameter types
*
* @return The index
*/
public int getIndex(Class[] parameterTypes) {
final Constructor[] constructors = this.type.getConstructors();
boolean eq;
for ( int i = 0; i < constructors.length; ++i ) {
if ( !Modifier.isPublic( constructors[i].getModifiers() ) ) {
continue;
}
final Class[] params = constructors[i].getParameterTypes();
if ( params.length != parameterTypes.length ) {
continue;
}
eq = true;
for ( int j = 0; j < params.length; ++j ) {
if ( !params[j].equals( parameterTypes[j] ) ) {
eq = false;
break;
}
}
if ( eq ) {
return i;
}
}
return -1;
}
/**
* Get the wrapped class name
*
* @return The class name
*/
public String getName() {
return this.type.getName();
}
/**
* Get the wrapped java class reference
*
* @return The class reference
*/
public Class getJavaClass() {
return this.type;
}
@Override
public String toString() {
return this.type.toString();
}
@Override
public int hashCode() {
return this.type.hashCode();
}
@Override
public boolean equals(Object o) {
return o instanceof FastClass
&& this.type.equals( ((FastClass) o).type );
}
}