/**
* 通过反射, 获得Class定义中声明的父类的泛型参数的类型. 如无法找到, 返回Object.class.
*
* <p>如public UserDao extends HibernateDao<User,Long>
*
* @param clazz clazz The class to introspect
* @param index the Index of the generic ddeclaration,start from 0.
* @return the index generic declaration, or Object.class if cannot be determined
*/
public static Class getSuperClassGenricType(final Class clazz, final int index) {
Type genType = clazz.getGenericSuperclass();
if (!(genType instanceof ParameterizedType)) {
logger.warn(clazz.getSimpleName() + "'s superclass not ParameterizedType");
return Object.class;
}
Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
if (index >= params.length || index < 0) {
logger.warn(
"Index: "
+ index
+ ", Size of "
+ clazz.getSimpleName()
+ "'s Parameterized Type: "
+ params.length);
return Object.class;
}
if (!(params[index] instanceof Class)) {
logger.warn(
clazz.getSimpleName() + " not set the actual class on superclass generic parameter");
return Object.class;
}
return (Class) params[index];
}
public void mapToType(Class<?> type) {
if (!targetType.isAssignableFrom(type)) {
throw new IllegalArgumentException(
String.format(
"requested wrapper type '%s' is not assignable to target type '%s'.",
type.getSimpleName(), targetType.getSimpleName()));
}
wrapperType = type;
}
/**
* Search a wiring method in the specified class.
*
* @param cl the class where to find the method
* @param methodName the method to be searched
* @return the requested method, if it fully conforms to the definition of the wiring methods.
*/
private static Method getMethod(Class cl, String methodName)
throws NoSuchMethodException, ClassNotFoundException {
// Search methods
Method[] methods = cl.getMethods();
ArrayList<Method> list = new ArrayList<Method>();
for (Method m : methods) {
if (m.getName().equals(methodName)) {
list.add(m);
}
}
if (list.size() == 0) {
throw new NoSuchMethodException(
"No method " + methodName + " in class " + cl.getSimpleName());
} else if (list.size() > 1) {
throw new NoSuchMethodException(
"Multiple methods called " + methodName + " in class " + cl.getSimpleName());
}
// Found a single method with the right name; check if
// it is a setter.
final Class graphClass = Class.forName("peersim.graph.Graph");
final Class randomClass = Class.forName("java.util.Random");
Method method = list.get(0);
Class[] pars = method.getParameterTypes();
if (pars.length < 1 || !pars[0].isAssignableFrom(graphClass))
throw new NoSuchMethodException(
method.getName()
+ " of class "
+ cl.getSimpleName()
+ " is not a valid graph wiring method,"
+ " it has to have peersim.graph.Graph as first argument type");
for (int i = 1; i < pars.length; ++i)
if (!(pars[i] == int.class
|| pars[i] == long.class
|| pars[i] == double.class
|| (i == pars.length - 1 && pars[i].isAssignableFrom(randomClass))))
throw new NoSuchMethodException(
method.getName()
+ " of class "
+ cl.getSimpleName()
+ " is not a valid graph wiring method");
if (method.toString().indexOf("static") < 0)
throw new NoSuchMethodException(
method.getName()
+ " of class "
+ cl.getSimpleName()
+ " is not a valid graph wiring method; it is not static");
return method;
}
private static int checkSingleArgument(
String subroutineName,
Class expectedType,
ArgumentsList arguments,
List<LispObject> args,
int argsCounter,
int i) {
try {
if (!(expectedType.isInstance(args.get(argsCounter)))) {
if (expectedType.equals(LispList.class)
&& args.get(argsCounter).equals(LispSymbol.ourNil)) {
arguments.setValue(i, LispList.list());
return argsCounter + 1;
}
if (expectedType.equals(LispSymbol.class)
&& args.get(argsCounter).equals(LispSymbol.ourNil)) {
arguments.setValue(i, LispSymbol.ourNil);
return argsCounter + 1;
}
if (arguments.isOptional(i)) return -1;
throw new WrongTypeArgumentException(expectedType.getSimpleName(), args.get(argsCounter));
}
arguments.setValue(i, args.get(argsCounter));
return argsCounter + 1;
} catch (IndexOutOfBoundsException e) {
if (arguments.isOptional(i)) return -1;
throw new WrongNumberOfArgumentsException(subroutineName, i);
}
}
public String toString() {
return "type="
+ type.getSimpleName()
+ ",data="
+ data.getClass().getSimpleName()
+ ':'
+ data;
}
@Override
public String toString() {
StringBuilder b = new StringBuilder();
for (Class<?> ann : annotations) {
b.append(ann.getSimpleName()).append(' ');
}
b.append((type instanceof Class<?>) ? ((Class<?>) type).getSimpleName() : type.toString());
return b.toString();
}
public void registerEntity(
Class<? extends Entity> cls,
String name,
int id,
int updateFrequency,
boolean sendVelocityUpdates) {
System.out.printf(
"%s: BaseMod.registerEntity: %s, \"%s\", %s\n",
getClass().getSimpleName(), cls.getSimpleName(), name, id);
EntityRegistry.registerModEntity(
cls, name, id, /*base*/ this, 256, updateFrequency, sendVelocityUpdates);
}
public MethodCallTester<MonitoredClass> assertMethodNotCalled(
String name, Class<?>... paramTypes) {
assertFalse(
"Method "
+ mockClass.getSimpleName()
+ "."
+ name
+ "("
+ Arrays.toString(paramTypes)
+ ") was called but no call was expected",
wasMethodCalled(name, paramTypes));
return this;
}
public MethodCallTester<MonitoredClass> assertMethodCalled(
String name, Object... expectedParamValues) {
assertTrue(
"Method "
+ mockClass.getSimpleName()
+ "."
+ name
+ "("
+ Arrays.toString(expectedParamValues)
+ ") was not called",
wasMethodCalled(name, expectedParamValues));
return this;
}
@SuppressWarnings("unused")
public MethodCallTester<MonitoredClass> assertMethodNotCalled(
String name, Object... expectedParamValues) {
assertFalse(
"Method "
+ mockClass.getSimpleName()
+ "."
+ name
+ "("
+ Arrays.toString(expectedParamValues)
+ ") was called but no call was expected",
wasMethodCalled(name, expectedParamValues));
return this;
}
/**
* Creates an instance of the class using the default constructor.
*
* @since 0.2.06
*/
@SuppressWarnings("cast")
private static <T> T newInstanceFromDefaultConstructor(Class<T> type) {
if (type == null) return null;
if (logger.isDebugEnabled()) logger.debug("Instantiating " + type.getSimpleName());
if (deprecated(type))
escalator.escalate(
"Instantiating a deprecated class: " + type.getName(), BeanUtil.class, null);
try {
return (T) type.newInstance();
} catch (InstantiationException e) {
throw ExceptionMapper.configurationException(e, type);
} catch (IllegalAccessException e) {
throw ExceptionMapper.configurationException(e, type);
}
}
@Override
public void execute() {
// to insert the selected string into the document
int pos = editor.getTextPaneEditor().getCaretPosition() - 1;
String content = null;
try {
content = editor.getTextPaneEditor().getText(0, pos + 1);
} catch (BadLocationException e) {
e.printStackTrace();
}
int w;
for (w = pos; w >= 0; w--) {
if (!Character.isLetter(content.charAt(w))) {
break;
}
}
String prefix = content.substring(w + 1).toLowerCase();
try {
String toInsert = getName().substring(prefix.length(), getName().length());
String[] args = null;
for (Method m : GraphOEditor.class.getMethods()) {
if (m.getName().equals(getName())) {
if (!(m.getParameterTypes().length == 0)) {
args = new String[m.getParameterTypes().length];
}
int cpt = 0;
for (Class c : m.getParameterTypes()) {
args[cpt] = c.getSimpleName();
cpt = cpt + 1;
}
}
}
toInsert = toInsert + "(";
if (!(args == null)) {
for (int i = 0; i < args.length; i++) {
if (i == (args.length - 1)) {
toInsert = toInsert + args[i];
} else {
toInsert = toInsert + args[i] + ",";
}
}
}
toInsert = toInsert + ");";
editor.getTextPaneEditor().getDocument().insertString(pos + 1, toInsert, null);
} catch (BadLocationException e) {
e.printStackTrace();
}
}
public boolean matchesDestructor(Class<?> type) {
if (!symbol.contains(type.getSimpleName())) {
return false;
}
parse();
try {
if (ref != null) {
return ref.matchesDestructor(type);
}
} catch (Exception ex) {
ex.printStackTrace();
}
return false;
}
/**
* Check that all methods declared in the given interface were called. Does *not* include
* methods from super interfaces.
*
* @return this for fluent api
*/
public MethodCallTester<MonitoredClass> assertAllInterfaceMethodsCalled() {
List<MethodInvocation> currentInvocation =
new ArrayList<>(invocations); // Debugger calling toString can mess with this
for (Method method : mockClass.getDeclaredMethods()) {
if (Modifier.isStatic(method.getModifiers()) || !Modifier.isPublic(method.getModifiers()))
continue;
boolean called = false;
for (MethodInvocation invocation : currentInvocation) {
if (invocation.method.equals(method.getName())) {
called = true;
break;
}
}
assertTrue(
"Method " + mockClass.getSimpleName() + "." + method.getName() + " was not called",
called);
}
return this;
}
private static <T, S> T adaptToEnum(Class<T> targetType, S sourceObject) {
try {
String literal;
if (sourceObject instanceof Enum) {
literal = ((Enum<?>) sourceObject).name();
} else if (sourceObject instanceof String) {
literal = (String) sourceObject;
} else {
literal = sourceObject.toString();
}
NotationParser<String, T> parser =
new NotationConverterToNotationParserAdapter<String, T>(
new EnumFromCharSequenceNotationParser(targetType));
T parsedLiteral = parser.parseNotation(literal);
return targetType.cast(parsedLiteral);
} catch (TypeConversionException e) {
throw new IllegalArgumentException(
String.format(
"Can't convert '%s' to enum type '%s'", sourceObject, targetType.getSimpleName()),
e);
}
}
public static String toString(Object bean, boolean simple) {
if (bean == null) return null;
Class<?> beanClass = bean.getClass();
StringBuilder builder =
new StringBuilder(simple ? beanClass.getSimpleName() : bean.getClass().getName());
PropertyDescriptor[] descriptors = getPropertyDescriptors(bean.getClass());
boolean first = true;
for (PropertyDescriptor descriptor : descriptors) {
String propertyName = descriptor.getName();
if (!"class".equals(propertyName) && descriptor.getReadMethod() != null) {
if (first) builder.append('[');
else builder.append(", ");
Object value = getPropertyValue(bean, propertyName);
String valueString = ToStringConverter.convert(value, "null");
builder.append(propertyName).append("=").append(valueString);
first = false;
}
}
if (!first) builder.append(']');
return builder.toString();
}
NullRobotProxyHandler(Class<? extends Robot> type) {
nullName = type.getSimpleName() + " NullRobot";
}
public String getPublicMethodsForClasses(String classNames[]) {
StringBuilder result = new StringBuilder();
String className = null;
result.append("<classDefinitions>");
if (classNames != null && classNames.length > 0) {
for (int i = 0; i < classNames.length; i++) {
className = classNames[i];
if (className != null) {
result.append("<classDefinition>");
try {
Class c = Class.forName(className);
result.append(
(new StringBuilder("<classSimpleName>"))
.append(c.getSimpleName())
.append("</classSimpleName>")
.toString());
result.append(
(new StringBuilder("<classFullName>"))
.append(c.getName())
.append("</classFullName>")
.toString());
Package pack = c.getPackage();
String packStr = "";
if (pack != null) packStr = pack.getName();
result.append(
(new StringBuilder("<packageName>"))
.append(packStr)
.append("</packageName>")
.toString());
Method methods[] = c.getMethods();
Method method = null;
result.append("<methods>");
if (methods != null) {
for (int j = 0; j < methods.length; j++) {
method = methods[j];
if (method != null && !methodsExclude.contains(method.getName())) {
result.append("<method>");
result.append(
(new StringBuilder("<methodSignature>"))
.append(method.toString())
.append("</methodSignature>")
.toString());
result.append(
(new StringBuilder("<methodName>"))
.append(method.getName())
.append("</methodName>")
.toString());
result.append(
(new StringBuilder("<returnType>"))
.append(method.getReturnType().getName())
.append("</returnType>")
.toString());
Class paramClasses[] = method.getParameterTypes();
result.append("<params>");
if (paramClasses != null) {
for (int l = 0; l < paramClasses.length; l++)
if (paramClasses[l] != null)
result.append(
(new StringBuilder("<param>"))
.append(paramClasses[l].getName())
.append("</param>")
.toString());
}
result.append("</params>");
result.append("</method>");
}
}
}
result.append("</methods>");
} catch (ClassNotFoundException e) {
result.append(
(new StringBuilder("<classFullName>"))
.append(className)
.append("</classFullName>")
.toString());
result.append(
(new StringBuilder("<error>Problem retrieving "))
.append(className)
.append(" information</error>")
.toString());
System.out.println(e.getMessage());
}
result.append("</classDefinition>");
}
}
}
result.append("</classDefinitions>");
return result.toString();
}
public String getPublicPropertiesForClasses(String classNames[]) {
StringBuilder result = new StringBuilder();
String className = null;
ArrayList publicFields = new ArrayList();
result.append("<classDefinitions>");
if (classNames != null && classNames.length > 0) {
for (int i = 0; i < classNames.length; i++) {
className = classNames[i];
if (className != null) {
result.append("<classDefinition>");
try {
Class c = Class.forName(className);
Field fields[] = c.getFields();
Field field = null;
if (fields != null) {
for (int k = 0; k < fields.length; k++) {
field = fields[k];
if (field != null)
publicFields.add(
(new StringBuilder(String.valueOf(field.getName())))
.append(",")
.append(field.getType().getName())
.toString());
}
}
try {
BeanInfo b = Introspector.getBeanInfo(c);
result.append(
(new StringBuilder("<classSimpleName>"))
.append(c.getSimpleName())
.append("</classSimpleName>")
.toString());
result.append(
(new StringBuilder("<classFullName>"))
.append(c.getName())
.append("</classFullName>")
.toString());
Package pack = c.getPackage();
String packStr = "";
if (pack != null) packStr = pack.getName();
result.append(
(new StringBuilder("<packageName>"))
.append(packStr)
.append("</packageName>")
.toString());
PropertyDescriptor pds[] = b.getPropertyDescriptors();
if (pds != null) {
for (int propCount = 0; propCount < pds.length; propCount++) {
PropertyDescriptor pd = pds[propCount];
String propertyName = pd.getName();
Method readMethod = pd.getReadMethod();
Method writeMethod = pd.getWriteMethod();
if (readMethod != null
&& isPublicAccessor(readMethod.getModifiers())
&& writeMethod != null
&& isPublicAccessor(writeMethod.getModifiers()))
publicFields.add(
(new StringBuilder(String.valueOf(propertyName)))
.append(",")
.append(pd.getPropertyType().getName())
.toString());
}
}
} catch (Exception e) {
e.printStackTrace();
}
if (publicFields != null && publicFields.size() > 0) {
String temp = null;
result.append("<publicFields>");
for (int counter = 0; counter < publicFields.size(); counter++) {
temp = (String) publicFields.get(counter);
if (temp != null) {
String pubTemp[] = temp.split(",");
if (pubTemp.length == 2) {
result.append("<publicField>");
result.append(
(new StringBuilder("<publicFieldName>"))
.append(pubTemp[0])
.append("</publicFieldName>")
.toString());
result.append(
(new StringBuilder("<publicFieldType>"))
.append(pubTemp[1])
.append("</publicFieldType>")
.toString());
result.append("</publicField>");
}
}
}
result.append("</publicFields>");
}
} catch (ClassNotFoundException e) {
result.append(
(new StringBuilder("<classFullName>"))
.append(className)
.append("</classFullName>")
.toString());
result.append(
(new StringBuilder("<error>Problem retrieving "))
.append(className)
.append(" information</error>")
.toString());
System.out.println(e.getMessage());
}
result.append("</classDefinition>");
}
}
}
result.append("</classDefinitions>");
return result.toString();
}
@Override
protected String[] errors() {
if (_type != null) return new String[] {"Key is not a " + _type.getSimpleName()};
return super.errors();
}
public ContextMutator(Class<?> aFor, Class<T> aWith, String aTagName) {
method = Classes.getMutatorMethod(aFor, aWith.getSimpleName(), aTagName);
}
public boolean matches(Type type, Annotations annotations) {
String thisName = getQualifiedName(new StringBuilder(), false).toString();
Class typeClass = getTypeClass(type);
String typeName = typeClass.getSimpleName();
return thisName.equals(typeName) || thisName.equals(typeClass.getName());
}
public static void main(String[] args) {
// Obtain the class object if we know the name of the class
Class rental = RentCar.class;
try {
// get the absolute name of the class
String rentalClassPackage = rental.getName();
System.out.println("Class Name is: " + rentalClassPackage);
// get the simple name of the class (without package info)
String rentalClassNoPackage = rental.getSimpleName();
System.out.println("Class Name without package is: " + rentalClassNoPackage);
// get the package name of the class
Package rentalPackage = rental.getPackage();
System.out.println("Package Name is: " + rentalPackage);
// get all the constructors of the class
Constructor[] constructors = rental.getConstructors();
System.out.println("Constructors are: " + Arrays.toString(constructors));
// get constructor with specific argument
Constructor constructor = rental.getConstructor(Integer.TYPE);
// initializing an object of the RentCar class
RentCar rent = (RentCar) constructor.newInstance(455);
// get all methods of the class including declared methods of
// superclasses
// in that case, superclass of RentCar is the class java.lang.Object
Method[] allmethods = rental.getMethods();
System.out.println("Methods are: " + Arrays.toString(allmethods));
for (Method method : allmethods) {
System.out.println("method = " + method.getName());
}
// get all methods declared in the class
// but excludes inherited methods.
Method[] declaredMethods = rental.getDeclaredMethods();
System.out.println("Declared Methods are: " + Arrays.toString(declaredMethods));
for (Method dmethod : declaredMethods) {
System.out.println("method = " + dmethod.getName());
}
// get method with specific name and parameters
Method oneMethod = rental.getMethod("computeRentalCost", new Class[] {Integer.TYPE});
System.out.println("Method is: " + oneMethod);
// call computeRentalCost method with parameter int
oneMethod.invoke(rent, 4);
// get all the parameters of computeRentalCost
Class[] parameterTypes = oneMethod.getParameterTypes();
System.out.println(
"Parameter types of computeRentalCost() are: " + Arrays.toString(parameterTypes));
// get the return type of computeRentalCost
Class returnType = oneMethod.getReturnType();
System.out.println("Return type is: " + returnType);
// gets all the public member fields of the class RentCar
Field[] fields = rental.getFields();
System.out.println("Public Fields are: ");
for (Field oneField : fields) {
// get public field name
Field field = rental.getField(oneField.getName());
String fieldname = field.getName();
System.out.println("Fieldname is: " + fieldname);
// get public field type
Object fieldType = field.getType();
System.out.println("Type of field " + fieldname + " is: " + fieldType);
// get public field value
Object value = field.get(rent);
System.out.println("Value of field " + fieldname + " is: " + value);
}
// How to access private member fields of the class
// getDeclaredField() returns the private field
Field privateField = RentCar.class.getDeclaredField("type");
String name = privateField.getName();
System.out.println("One private Fieldname is: " + name);
// makes this private field instance accessible
// for reflection use only, not normal code
privateField.setAccessible(true);
// get the value of this private field
String fieldValue = (String) privateField.get(rent);
System.out.println("fieldValue = " + fieldValue);
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
@Override
protected String queryDescription() {
return "A key" + (_type != null ? " of type " + _type.getSimpleName() : "");
}
