Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * fb-contrib - Auxiliary detectors for Java programs
   * Copyright (C) 2005-2012 Dave Brosius
   * 
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   * 
  * This library 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
  * Lesser General Public License for more details.
  * 
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 package com.mebigfatguy.fbcontrib.utils;
 
 import java.util.Map;
 
 import  org.apache.bcel.Constants;
 import  org.apache.bcel.classfile.JavaClass;
 import  org.apache.bcel.classfile.Method;
 import  org.apache.bcel.generic.Type;
 
 public class SignatureUtils {
 
 	public static boolean isInheritedMethod(JavaClass clsString methodNameString signaturethrows ClassNotFoundException {
 		JavaClass[] infs = cls.getAllInterfaces();
 		if (findInheritedMethod(infsmethodNamesignature) != null) {
 			return true;
 		}
 
 		JavaClass[] supers = cls.getSuperClasses();
 		for (int i = 0; i < supers.length; i++) {
 			if ("java.lang.Object".equals(supers[i].getClassName())) {
 				supers[i] = null;
 			}
 		}
 		return findInheritedMethod(supersmethodNamesignature) != null;
 	}

parses the package name from a fully qualified class name

Parameters:
className the class in question
Returns:
the package of the class
 
 	public static String getPackageName(final String className) {
 		int dotPos = className.lastIndexOf('.');
 		if (dotPos < 0) {
 			return "";
 		}
 		return className.substring(0, dotPos);
 	}

returns whether or not the two packages have the same first 'depth' parts, if they exist

Parameters:
packName1 the first package to check
packName2 the second package to check
depth the number of package parts to check
Returns:
if they are similar
 
 	public static boolean similarPackages(String packName1String packName2int depth) {
 		if (depth == 0) {
 			return true;
 		}
 
 		packName1 = packName1.replace('/''.');
 		packName2 = packName2.replace('/''.');
 
 		int dot1 = packName1.indexOf('.');
 		int dot2 = packName2.indexOf('.');
 		if (dot1 < 0) {
 			return (dot2 < 0);
 		} else if (dot2 < 0) {
 			return false;
 		}
 
 		String s1 = packName1.substring(0, dot1);
 		String s2 = packName2.substring(0, dot2);
 
 		if (!s1.equals(s2)) {
 			return false;
 		}
 
 		return similarPackages(packName1.substring(dot1+1), packName2.substring(dot2+1), depth-1);
 	}

converts a primitive type code to a signature
 
 	public static String getTypeCodeSignature(int typeCode) {
		switch (typeCode) {
			case Constants.T_BOOLEAN:
				return "Z";
			case Constants.T_CHAR:
				return "C";
			case Constants.T_FLOAT:
				return "F";
			case Constants.T_DOUBLE:
				return "D";
			case Constants.T_BYTE:
				return "B";
			case Constants.T_SHORT:
				return "S";
			case Constants.T_INT:
				return "I";
			case Constants.T_LONG:
				return "L";
		}
		return "Ljava/lang/Object;";
	}
	private static JavaClass findInheritedMethod(JavaClass[] classesString methodNameString signature) {
		for (JavaClass cls : classes) {
			if (cls != null) {
				Method[] methods = cls.getMethods();
				for (Method m : methods) {
					if (!m.isPrivate()) {
						if (m.getName().equals(methodName)) {
							if (m.getSignature().equals(signature)) {
								return cls;
							}
						}
					}
				}
			}
		}
		return null;
	}

returns a Map that represents the type of the parameter in slot x

Parameters:
m the method for which you want the parameters
Returns:
a map of parameter types (expect empty slots when doubles/longs are used
	public static Map<IntegerStringgetParameterSignatures(Method m) {
	    Type[] parms = m.getArgumentTypes();
	    
	    Map<IntegerStringparmSigs = new LinkedHashMap<IntegerString>();
	    
	    int slot = m.isStatic() ? 0 : 1;
	    for (Type t : parms) {
	        String signature = t.getSignature();
	        parmSigs.put(Integer.valueOf(slot), signature);
	        slot += ("J".equals(signature) || "D".equals(signature)) ? 2 : 1;
	    }
	    
	    return parmSigs;
	}
New to GrepCode? Check out our FAQ X