Method.java

/***
 * ASM: a very small and fast Java bytecode manipulation framework
 * Copyright (c) 2000-2005 INRIA, France Telecom
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the copyright holders nor the names of its
 *    contributors may be used to endorse or promote products derived from
 *    this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */
package clojure.asm.commons;

import java.util.HashMap;
import java.util.Map;

import clojure.asm.Type;

/**
 * A named method descriptor.
 *
 * @author Juozas Baliuka
 * @author Chris Nokleberg
 * @author Eric Bruneton
 */
public class Method{

/**
 * The method name.
 */
private final String name;

/**
 * The method descriptor.
 */
private final String desc;

/**
 * Maps primitive Java type names to their descriptors.
 */
private final static Map DESCRIPTORS;

static
	{
	DESCRIPTORS = new HashMap();
	DESCRIPTORS.put("void", "V");
	DESCRIPTORS.put("byte", "B");
	DESCRIPTORS.put("char", "C");
	DESCRIPTORS.put("double", "D");
	DESCRIPTORS.put("float", "F");
	DESCRIPTORS.put("int", "I");
	DESCRIPTORS.put("long", "J");
	DESCRIPTORS.put("short", "S");
	DESCRIPTORS.put("boolean", "Z");
	}

/**
 * Creates a new {@link Method}.
 *
 * @param name the method's name.
 * @param desc the method's descriptor.
 */
public Method(final String name, final String desc){
	this.name = name;
	this.desc = desc;
}

/**
 * Creates a new {@link Method}.
 *
 * @param name          the method's name.
 * @param returnType    the method's return type.
 * @param argumentTypes the method's argument types.
 */
public Method(
		final String name,
		final Type returnType,
		final Type[] argumentTypes){
	this(name, Type.getMethodDescriptor(returnType, argumentTypes));
}

/**
 * Returns a {@link Method} corresponding to the given Java method
 * declaration.
 *
 * @param method a Java method declaration, without argument names, of the
 *               form "returnType name (argumentType1, ... argumentTypeN)", where
 *               the types are in plain Java (e.g. "int", "float",
 *               "java.util.List", ...). Classes of the java.lang package can be
 *               specified by their unqualified name; all other classes names must
 *               be fully qualified.
 * @return a {@link Method} corresponding to the given Java method
 *         declaration.
 * @throws IllegalArgumentException if <code>method</code> could not get
 *                                  parsed.
 */
public static Method getMethod(final String method)
		throws IllegalArgumentException{
	return getMethod(method, false);
}

/**
 * Returns a {@link Method} corresponding to the given Java method
 * declaration.
 *
 * @param method         a Java method declaration, without argument names, of the
 *                       form "returnType name (argumentType1, ... argumentTypeN)", where
 *                       the types are in plain Java (e.g. "int", "float",
 *                       "java.util.List", ...). Classes of the java.lang package may be
 *                       specified by their unqualified name, depending on the
 *                       defaultPackage argument; all other classes names must be fully
 *                       qualified.
 * @param defaultPackage true if unqualified class names belong to the
 *                       default package, or false if they correspond to java.lang classes.
 *                       For instance "Object" means "Object" if this option is true, or
 *                       "java.lang.Object" otherwise.
 * @return a {@link Method} corresponding to the given Java method
 *         declaration.
 * @throws IllegalArgumentException if <code>method</code> could not get
 *                                  parsed.
 */
public static Method getMethod(
		final String method,
		final boolean defaultPackage) throws IllegalArgumentException{
	int space = method.indexOf(' ');
	int start = method.indexOf('(', space) + 1;
	int end = method.indexOf(')', start);
	if(space == -1 || start == -1 || end == -1)
		{
		throw new IllegalArgumentException();
		}
	// TODO: Check validity of returnType, methodName and arguments.
	String returnType = method.substring(0, space);
	String methodName = method.substring(space + 1, start - 1).trim();
	StringBuffer sb = new StringBuffer();
	sb.append('(');
	int p;
	do
		{
		String s;
		p = method.indexOf(',', start);
		if(p == -1)
			{
			s = map(method.substring(start, end).trim(), defaultPackage);
			}
		else
			{
			s = map(method.substring(start, p).trim(), defaultPackage);
			start = p + 1;
			}
		sb.append(s);
		} while(p != -1);
	sb.append(')');
	sb.append(map(returnType, defaultPackage));
	return new Method(methodName, sb.toString());
}

private static String map(final String type, final boolean defaultPackage){
	if(type.equals(""))
		{
		return type;
		}

	StringBuffer sb = new StringBuffer();
	int index = 0;
	while((index = type.indexOf("[]", index) + 1) > 0)
		{
		sb.append('[');
		}

	String t = type.substring(0, type.length() - sb.length() * 2);
	String desc = (String) DESCRIPTORS.get(t);
	if(desc != null)
		{
		sb.append(desc);
		}
	else
		{
		sb.append('L');
		if(t.indexOf('.') < 0)
			{
			if(!defaultPackage)
				{
				sb.append("java/lang/");
				}
			sb.append(t);
			}
		else
			{
			sb.append(t.replace('.', '/'));
			}
		sb.append(';');
		}
	return sb.toString();
}

/**
 * Returns the name of the method described by this object.
 *
 * @return the name of the method described by this object.
 */
public String getName(){
	return name;
}

/**
 * Returns the descriptor of the method described by this object.
 *
 * @return the descriptor of the method described by this object.
 */
public String getDescriptor(){
	return desc;
}

/**
 * Returns the return type of the method described by this object.
 *
 * @return the return type of the method described by this object.
 */
public Type getReturnType(){
	return Type.getReturnType(desc);
}

/**
 * Returns the argument types of the method described by this object.
 *
 * @return the argument types of the method described by this object.
 */
public Type[] getArgumentTypes(){
	return Type.getArgumentTypes(desc);
}

public String toString(){
	return name + desc;
}

public boolean equals(final Object o){
	if(!(o instanceof Method))
		{
		return false;
		}
	Method other = (Method) o;
	return name.equals(other.name) && desc.equals(other.desc);
}

public int hashCode(){
	return name.hashCode() ^ desc.hashCode();
}
}