mirror of
https://github.com/IntellectualSites/PlotSquared.git
synced 2024-06-27 10:35:04 +02:00
687 lines
21 KiB
Java
687 lines
21 KiB
Java
package com.plotsquared.core.util;
|
|
|
|
import java.lang.reflect.Constructor;
|
|
import java.lang.reflect.Field;
|
|
import java.lang.reflect.InvocationTargetException;
|
|
import java.lang.reflect.Method;
|
|
import java.lang.reflect.Modifier;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Collections;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
/**
|
|
* @author DPOH-VAR
|
|
* @version 1.0
|
|
*/
|
|
public class ReflectionUtils {
|
|
|
|
/**
|
|
* prefix of bukkit classes
|
|
*/
|
|
private static String preClassB = "org.bukkit.craftbukkit";
|
|
/**
|
|
* prefix of minecraft classes
|
|
*/
|
|
private static String preClassM = "net.minecraft.server";
|
|
|
|
public ReflectionUtils(String version) {
|
|
if (version != null) {
|
|
preClassB += '.' + version;
|
|
preClassM += '.' + version;
|
|
}
|
|
}
|
|
|
|
public static <T, V> Map<T, V> getMap(Map<T, V> map) {
|
|
try {
|
|
Class<? extends Map> clazz = map.getClass();
|
|
Field m = clazz.getDeclaredField("m");
|
|
m.setAccessible(true);
|
|
return (Map<T, V>) m.get(map);
|
|
} catch (Throwable e) {
|
|
e.printStackTrace();
|
|
return map;
|
|
}
|
|
}
|
|
|
|
public static Method findMethod(Class<?> clazz, boolean isStatic, Class<?> returnType,
|
|
Class... types) {
|
|
loop:
|
|
for (Method method : clazz.getMethods()) {
|
|
Class<?> result = method.getReturnType();
|
|
Class<?>[] param = method.getParameterTypes();
|
|
int paramCount = param.length;
|
|
boolean stc = Modifier.isStatic(method.getModifiers());
|
|
if (stc == isStatic && result == returnType && types.length == paramCount) {
|
|
for (int i = 0; i < types.length; i++) {
|
|
if (types[i] != param[i]) {
|
|
continue loop;
|
|
}
|
|
}
|
|
method.setAccessible(true);
|
|
return method;
|
|
}
|
|
}
|
|
throw new RuntimeException("no such method");
|
|
}
|
|
|
|
public static Field findField(Class<?> clazz, Class<?> fieldClass) {
|
|
for (Field field : clazz.getFields()) {
|
|
if (fieldClass == field.getType() || fieldClass.isAssignableFrom(field.getType())) {
|
|
field.setAccessible(true);
|
|
return field;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static <T> List<T> getStaticFields(Class clazz) {
|
|
ArrayList<T> list = new ArrayList<T>();
|
|
try {
|
|
Field[] fields = clazz.getFields();
|
|
for (Field field : fields) {
|
|
Object value = field.get(null);
|
|
try {
|
|
list.add((T) value);
|
|
} catch (ClassCastException ignored) {
|
|
}
|
|
}
|
|
} catch (IllegalAccessException | IllegalArgumentException | SecurityException e) {
|
|
e.printStackTrace();
|
|
}
|
|
return list;
|
|
}
|
|
|
|
public static Class<?> getNmsClass(String name) {
|
|
String className = preClassM + '.' + name;
|
|
return getClass(className);
|
|
}
|
|
|
|
public static Class<?> getCbClass(String name) {
|
|
String className = preClassB + '.' + name;
|
|
return getClass(className);
|
|
}
|
|
|
|
public static Class<?> getUtilClass(String name) {
|
|
try {
|
|
return Class.forName(name); //Try before 1.8 first
|
|
} catch (ClassNotFoundException ignored) {
|
|
}
|
|
try {
|
|
return Class.forName("net.minecraft.util." + name); //Not 1.8
|
|
} catch (ClassNotFoundException ignored) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static Object getHandle(Object wrapper) {
|
|
Method getHandle = makeMethod(wrapper.getClass(), "getHandle");
|
|
return callMethod(getHandle, wrapper);
|
|
}
|
|
|
|
//Utils
|
|
public static Method makeMethod(Class<?> clazz, String methodName, Class<?>... paramaters) {
|
|
try {
|
|
return clazz.getDeclaredMethod(methodName, paramaters);
|
|
} catch (NoSuchMethodException ignored) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
public static <T> T callMethod(Method method, Object instance, Object... paramaters) {
|
|
if (method == null) {
|
|
throw new RuntimeException("No such method");
|
|
}
|
|
method.setAccessible(true);
|
|
try {
|
|
return (T) method.invoke(instance, paramaters);
|
|
} catch (InvocationTargetException ex) {
|
|
throw new RuntimeException(ex.getCause());
|
|
} catch (IllegalAccessException | IllegalArgumentException ex) {
|
|
throw new RuntimeException(ex);
|
|
}
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
public static <T> Constructor<T> makeConstructor(Class<?> clazz, Class<?>... parameterTypes) {
|
|
try {
|
|
return (Constructor<T>) clazz.getConstructor(parameterTypes);
|
|
} catch (NoSuchMethodException ignored) {
|
|
//todo print a constructor not found method
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static <T> T callConstructor(Constructor<T> constructor, Object... parameters) {
|
|
if (constructor == null) {
|
|
throw new RuntimeException("No such constructor");
|
|
}
|
|
constructor.setAccessible(true);
|
|
try {
|
|
return constructor.newInstance(parameters);
|
|
} catch (InvocationTargetException ex) {
|
|
throw new RuntimeException(ex.getCause());
|
|
} catch (IllegalAccessException | IllegalArgumentException | InstantiationException ex) {
|
|
throw new RuntimeException(ex);
|
|
}
|
|
}
|
|
|
|
public static Field makeField(Class<?> clazz, String name) {
|
|
try {
|
|
return clazz.getDeclaredField(name);
|
|
} catch (NoSuchFieldException ignored) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@SuppressWarnings("unchecked") public static <T> T getField(Field field, Object instance) {
|
|
if (field == null) {
|
|
throw new RuntimeException("No such field");
|
|
}
|
|
field.setAccessible(true);
|
|
try {
|
|
return (T) field.get(instance);
|
|
} catch (IllegalAccessException | IllegalArgumentException ex) {
|
|
throw new RuntimeException(ex);
|
|
}
|
|
}
|
|
|
|
public static void setField(Field field, Object instance, Object value) {
|
|
if (field == null) {
|
|
throw new RuntimeException("No such field");
|
|
}
|
|
field.setAccessible(true);
|
|
try {
|
|
field.set(instance, value);
|
|
} catch (IllegalAccessException | IllegalArgumentException ex) {
|
|
throw new RuntimeException(ex);
|
|
}
|
|
}
|
|
|
|
public static Class<?> getClass(String name) {
|
|
try {
|
|
return Class.forName(name);
|
|
} catch (ClassNotFoundException ignored) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static <T> Class<? extends T> getClass(String name, Class<T> superClass) {
|
|
try {
|
|
return Class.forName(name).asSubclass(superClass);
|
|
} catch (ClassCastException | ClassNotFoundException ignored) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get class for name. Replace {nms} to net.minecraft.server.V*. Replace {cb} to org.bukkit.craftbukkit.V*. Replace
|
|
* {nm} to net.minecraft
|
|
*
|
|
* @param className possible class paths
|
|
* @return RefClass object
|
|
* @throws ClassNotFoundException if no class found
|
|
*/
|
|
public static RefClass getRefClass(String className) throws ClassNotFoundException {
|
|
className = className.replace("{cb}", preClassB).replace("{nms}", preClassM)
|
|
.replace("{nm}", "net.minecraft");
|
|
return getRefClass(Class.forName(className));
|
|
}
|
|
|
|
/**
|
|
* get RefClass object by real class
|
|
*
|
|
* @param clazz class
|
|
* @return RefClass based on passed class
|
|
*/
|
|
public static RefClass getRefClass(Class clazz) {
|
|
return new RefClass(clazz);
|
|
}
|
|
|
|
/**
|
|
* RefClass - utility to simplify work with reflections.
|
|
*/
|
|
public static class RefClass {
|
|
|
|
private final Class<?> clazz;
|
|
|
|
private RefClass(Class<?> clazz) {
|
|
this.clazz = clazz;
|
|
}
|
|
|
|
/**
|
|
* get passed class
|
|
*
|
|
* @return class
|
|
*/
|
|
public Class<?> getRealClass() {
|
|
return this.clazz;
|
|
}
|
|
|
|
/**
|
|
* see {@link Class#isInstance(Object)}
|
|
*
|
|
* @param object the object to check
|
|
* @return true if object is an instance of this class
|
|
*/
|
|
public boolean isInstance(Object object) {
|
|
return this.clazz.isInstance(object);
|
|
}
|
|
|
|
/**
|
|
* get existing method by name and types
|
|
*
|
|
* @param name name
|
|
* @param types method parameters. can be Class or RefClass
|
|
* @return RefMethod object
|
|
* @throws RuntimeException if method not found
|
|
*/
|
|
public RefMethod getMethod(String name, Object... types) throws NoSuchMethodException {
|
|
Class[] classes = new Class[types.length];
|
|
int i = 0;
|
|
for (Object e : types) {
|
|
if (e instanceof Class) {
|
|
classes[i++] = (Class) e;
|
|
} else if (e instanceof RefClass) {
|
|
classes[i++] = ((RefClass) e).getRealClass();
|
|
} else {
|
|
classes[i++] = e.getClass();
|
|
}
|
|
}
|
|
try {
|
|
return new RefMethod(this.clazz.getMethod(name, classes));
|
|
} catch (NoSuchMethodException ignored) {
|
|
return new RefMethod(this.clazz.getDeclaredMethod(name, classes));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* get existing constructor by types
|
|
*
|
|
* @param types parameters. can be Class or RefClass
|
|
* @return RefMethod object
|
|
* @throws RuntimeException if constructor not found
|
|
*/
|
|
public RefConstructor getConstructor(Object... types) throws NoSuchMethodException {
|
|
Class[] classes = new Class[types.length];
|
|
int i = 0;
|
|
for (Object e : types) {
|
|
if (e instanceof Class) {
|
|
classes[i++] = (Class) e;
|
|
} else if (e instanceof RefClass) {
|
|
classes[i++] = ((RefClass) e).getRealClass();
|
|
} else {
|
|
classes[i++] = e.getClass();
|
|
}
|
|
}
|
|
try {
|
|
return new RefConstructor(this.clazz.getConstructor(classes));
|
|
} catch (NoSuchMethodException ignored) {
|
|
return new RefConstructor(this.clazz.getDeclaredConstructor(classes));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* find method by type parameters
|
|
*
|
|
* @param types parameters. can be Class or RefClass
|
|
* @return RefMethod object
|
|
* @throws RuntimeException if method not found
|
|
*/
|
|
public RefMethod findMethod(Object... types) {
|
|
Class[] classes = new Class[types.length];
|
|
int t = 0;
|
|
for (Object e : types) {
|
|
if (e instanceof Class) {
|
|
classes[t++] = (Class) e;
|
|
} else if (e instanceof RefClass) {
|
|
classes[t++] = ((RefClass) e).getRealClass();
|
|
} else {
|
|
classes[t++] = e.getClass();
|
|
}
|
|
}
|
|
List<Method> methods = new ArrayList<>();
|
|
Collections.addAll(methods, this.clazz.getMethods());
|
|
Collections.addAll(methods, this.clazz.getDeclaredMethods());
|
|
findMethod:
|
|
for (Method m : methods) {
|
|
Class<?>[] methodTypes = m.getParameterTypes();
|
|
if (methodTypes.length != classes.length) {
|
|
continue;
|
|
}
|
|
for (Class aClass : classes) {
|
|
if (!Arrays.equals(classes, methodTypes)) {
|
|
continue findMethod;
|
|
}
|
|
return new RefMethod(m);
|
|
}
|
|
}
|
|
throw new RuntimeException("no such method");
|
|
}
|
|
|
|
/**
|
|
* find method by name
|
|
*
|
|
* @param names possible names of method
|
|
* @return RefMethod object
|
|
* @throws RuntimeException if method not found
|
|
*/
|
|
public RefMethod findMethodByName(String... names) {
|
|
List<Method> methods = new ArrayList<>();
|
|
Collections.addAll(methods, this.clazz.getMethods());
|
|
Collections.addAll(methods, this.clazz.getDeclaredMethods());
|
|
for (Method m : methods) {
|
|
for (String name : names) {
|
|
if (m.getName().equals(name)) {
|
|
return new RefMethod(m);
|
|
}
|
|
}
|
|
}
|
|
throw new RuntimeException("no such method");
|
|
}
|
|
|
|
/**
|
|
* find method by return value
|
|
*
|
|
* @param type type of returned value
|
|
* @return RefMethod
|
|
* @throws RuntimeException if method not found
|
|
*/
|
|
public RefMethod findMethodByReturnType(RefClass type) {
|
|
return findMethodByReturnType(type.clazz);
|
|
}
|
|
|
|
/**
|
|
* find method by return value
|
|
*
|
|
* @param type type of returned value
|
|
* @return RefMethod
|
|
* @throws RuntimeException if method not found
|
|
*/
|
|
public RefMethod findMethodByReturnType(Class type) {
|
|
if (type == null) {
|
|
type = void.class;
|
|
}
|
|
List<Method> methods = new ArrayList<>();
|
|
Collections.addAll(methods, this.clazz.getMethods());
|
|
Collections.addAll(methods, this.clazz.getDeclaredMethods());
|
|
for (Method m : methods) {
|
|
if (type.equals(m.getReturnType())) {
|
|
return new RefMethod(m);
|
|
}
|
|
}
|
|
throw new RuntimeException("no such method");
|
|
}
|
|
|
|
/**
|
|
* find constructor by number of arguments
|
|
*
|
|
* @param number number of arguments
|
|
* @return RefConstructor
|
|
* @throws RuntimeException if constructor not found
|
|
*/
|
|
public RefConstructor findConstructor(int number) {
|
|
List<Constructor> constructors = new ArrayList<>();
|
|
Collections.addAll(constructors, this.clazz.getConstructors());
|
|
Collections.addAll(constructors, this.clazz.getDeclaredConstructors());
|
|
for (Constructor m : constructors) {
|
|
if (m.getParameterTypes().length == number) {
|
|
return new RefConstructor(m);
|
|
}
|
|
}
|
|
throw new RuntimeException("no such constructor");
|
|
}
|
|
|
|
/**
|
|
* get field by name
|
|
*
|
|
* @param name field name
|
|
* @return RefField
|
|
* @throws RuntimeException if field not found
|
|
*/
|
|
public RefField getField(String name) throws NoSuchFieldException {
|
|
try {
|
|
return new RefField(this.clazz.getField(name));
|
|
} catch (NoSuchFieldException ignored) {
|
|
return new RefField(this.clazz.getDeclaredField(name));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* find field by type
|
|
*
|
|
* @param type field type
|
|
* @return RefField
|
|
* @throws RuntimeException if field not found
|
|
*/
|
|
public RefField findField(RefClass type) {
|
|
return findField(type.clazz);
|
|
}
|
|
|
|
/**
|
|
* find field by type
|
|
*
|
|
* @param type field type
|
|
* @return RefField
|
|
* @throws RuntimeException if field not found
|
|
*/
|
|
public RefField findField(Class type) {
|
|
if (type == null) {
|
|
type = void.class;
|
|
}
|
|
List<Field> fields = new ArrayList<>();
|
|
Collections.addAll(fields, this.clazz.getFields());
|
|
Collections.addAll(fields, this.clazz.getDeclaredFields());
|
|
for (Field f : fields) {
|
|
if (type.equals(f.getType())) {
|
|
return new RefField(f);
|
|
}
|
|
}
|
|
throw new RuntimeException("no such field");
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Method wrapper
|
|
*/
|
|
public static class RefMethod {
|
|
|
|
private final Method method;
|
|
|
|
private RefMethod(Method method) {
|
|
this.method = method;
|
|
method.setAccessible(true);
|
|
}
|
|
|
|
/**
|
|
* @return passed method
|
|
*/
|
|
public Method getRealMethod() {
|
|
return this.method;
|
|
}
|
|
|
|
/**
|
|
* @return owner class of method
|
|
*/
|
|
public RefClass getRefClass() {
|
|
return new RefClass(this.method.getDeclaringClass());
|
|
}
|
|
|
|
/**
|
|
* @return class of method return type
|
|
*/
|
|
public RefClass getReturnRefClass() {
|
|
return new RefClass(this.method.getReturnType());
|
|
}
|
|
|
|
/**
|
|
* apply method to object
|
|
*
|
|
* @param e object to which the method is applied
|
|
* @return RefExecutor with method call(...)
|
|
*/
|
|
public RefExecutor of(Object e) {
|
|
return new RefExecutor(e);
|
|
}
|
|
|
|
/**
|
|
* call static method
|
|
*
|
|
* @param params sent parameters
|
|
* @return return value
|
|
*/
|
|
public Object call(Object... params) {
|
|
try {
|
|
return this.method.invoke(null, params);
|
|
} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
|
|
throw new RuntimeException(e);
|
|
}
|
|
}
|
|
|
|
public class RefExecutor {
|
|
|
|
final Object e;
|
|
|
|
public RefExecutor(Object e) {
|
|
this.e = e;
|
|
}
|
|
|
|
/**
|
|
* apply method for selected object
|
|
*
|
|
* @param params sent parameters
|
|
* @return return value
|
|
* @throws RuntimeException if something went wrong
|
|
*/
|
|
public Object call(Object... params) {
|
|
try {
|
|
return RefMethod.this.method.invoke(this.e, params);
|
|
} catch (Exception e) {
|
|
throw new RuntimeException(e);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Constructor wrapper
|
|
*/
|
|
public static class RefConstructor {
|
|
|
|
private final Constructor constructor;
|
|
|
|
private RefConstructor(Constructor constructor) {
|
|
this.constructor = constructor;
|
|
constructor.setAccessible(true);
|
|
}
|
|
|
|
/**
|
|
* @return passed constructor
|
|
*/
|
|
public Constructor getRealConstructor() {
|
|
return this.constructor;
|
|
}
|
|
|
|
/**
|
|
* @return owner class of method
|
|
*/
|
|
public RefClass getRefClass() {
|
|
return new RefClass(this.constructor.getDeclaringClass());
|
|
}
|
|
|
|
/**
|
|
* create new instance with constructor
|
|
*
|
|
* @param params parameters for constructor
|
|
* @return new object
|
|
* @throws ReflectiveOperationException
|
|
* @throws IllegalArgumentException
|
|
*/
|
|
public Object create(Object... params)
|
|
throws ReflectiveOperationException, IllegalArgumentException {
|
|
return this.constructor.newInstance(params);
|
|
}
|
|
}
|
|
|
|
|
|
public static class RefField {
|
|
|
|
private final Field field;
|
|
|
|
private RefField(Field field) {
|
|
this.field = field;
|
|
field.setAccessible(true);
|
|
}
|
|
|
|
/**
|
|
* @return passed field
|
|
*/
|
|
public Field getRealField() {
|
|
return this.field;
|
|
}
|
|
|
|
/**
|
|
* @return owner class of field
|
|
*/
|
|
public RefClass getRefClass() {
|
|
return new RefClass(this.field.getDeclaringClass());
|
|
}
|
|
|
|
/**
|
|
* @return type of field
|
|
*/
|
|
public RefClass getFieldRefClass() {
|
|
return new RefClass(this.field.getType());
|
|
}
|
|
|
|
/**
|
|
* apply fiend for object
|
|
*
|
|
* @param e applied object
|
|
* @return RefExecutor with getter and setter
|
|
*/
|
|
public RefExecutor of(Object e) {
|
|
return new RefExecutor(e);
|
|
}
|
|
|
|
public class RefExecutor {
|
|
|
|
final Object e;
|
|
|
|
public RefExecutor(Object e) {
|
|
this.e = e;
|
|
}
|
|
|
|
/**
|
|
* set field value for applied object
|
|
*
|
|
* @param param value
|
|
*/
|
|
public void set(Object param) {
|
|
try {
|
|
RefField.this.field.set(this.e, param);
|
|
} catch (Exception e) {
|
|
throw new RuntimeException(e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* get field value for applied object
|
|
*
|
|
* @return value of field
|
|
*/
|
|
public Object get() {
|
|
try {
|
|
return RefField.this.field.get(this.e);
|
|
} catch (Exception e) {
|
|
throw new RuntimeException(e);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|