/
ReflectionUtil.java
158 lines (133 loc) · 5.42 KB
/
ReflectionUtil.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
package net.aufdemrand.denizen.utilities;
import org.bukkit.Bukkit;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
/**
* ReflectionUtil v1.1
*
* You are welcome to use it, modify it and redistribute it under the condition to not claim this class as your own
*
* @author DarkBlade12
*/
public abstract class ReflectionUtil {
private static final Map<Class<?>, Class<?>> CORRESPONDING_TYPES = new HashMap<Class<?>, Class<?>>();
static {
CORRESPONDING_TYPES.put(Byte.class, byte.class);
CORRESPONDING_TYPES.put(Short.class, short.class);
CORRESPONDING_TYPES.put(Integer.class, int.class);
CORRESPONDING_TYPES.put(Long.class, long.class);
CORRESPONDING_TYPES.put(Character.class, char.class);
CORRESPONDING_TYPES.put(Float.class, float.class);
CORRESPONDING_TYPES.put(Double.class, double.class);
CORRESPONDING_TYPES.put(Boolean.class, boolean.class);
}
public enum DynamicPackage {
MINECRAFT_SERVER {
@Override
public String toString() {
return "net.minecraft.server." + Bukkit.getServer().getClass().getPackage().getName().substring(23, 30);
}
},
CRAFTBUKKIT {
@Override
public String toString() {
return Bukkit.getServer().getClass().getPackage().getName();
}
};
}
public static class FieldEntry {
String key;
Object value;
public FieldEntry(String key, Object value) {
this.key = key;
this.value = value;
}
public String getKey() {
return this.key;
}
public Object getValue() {
return this.value;
}
}
private static Class<?> getPrimitiveType(Class<?> clazz) {
return CORRESPONDING_TYPES.containsKey(clazz) ? CORRESPONDING_TYPES.get(clazz) : clazz;
}
private static Class<?>[] toPrimitiveTypeArray(Object[] objects) {
int a = objects != null ? objects.length : 0;
Class<?>[] types = new Class<?>[a];
for (int i = 0; i < a; i++)
types[i] = getPrimitiveType(objects[i].getClass());
return types;
}
private static Class<?>[] toPrimitiveTypeArray(Class<?>[] classes) {
int a = classes != null ? classes.length : 0;
Class<?>[] types = new Class<?>[a];
for (int i = 0; i < a; i++)
types[i] = getPrimitiveType(classes[i]);
return types;
}
private static boolean equalsTypeArray(Class<?>[] a, Class<?>[] o) {
if (a.length != o.length)
return false;
for (int i = 0; i < a.length; i++)
if (!a[i].equals(o[i]) && !a[i].isAssignableFrom(o[i]))
return false;
return true;
}
public static Class<?> getClass(String name, DynamicPackage pack, String subPackage) throws Exception {
return Class.forName(pack + (subPackage != null && subPackage.length() > 0 ? "." + subPackage : "") + "." + name);
}
public static Class<?> getClass(String name, DynamicPackage pack) throws Exception {
return getClass(name, pack, null);
}
public static Constructor<?> getConstructor(Class<?> clazz, Class<?>... paramTypes) {
Class<?>[] t = toPrimitiveTypeArray(paramTypes);
for (Constructor<?> c : clazz.getConstructors()) {
Class<?>[] types = toPrimitiveTypeArray(c.getParameterTypes());
if (equalsTypeArray(types, t))
return c;
}
return null;
}
public static Object newInstance(Class<?> clazz, Object... args) throws Exception {
return getConstructor(clazz, toPrimitiveTypeArray(args)).newInstance(args);
}
public static Object newInstance(String name, DynamicPackage pack, String subPackage, Object... args) throws Exception {
return newInstance(getClass(name, pack, subPackage), args);
}
public static Object newInstance(String name, DynamicPackage pack, Object... args) throws Exception {
return newInstance(getClass(name, pack, null), args);
}
public static Method getMethod(String name, Class<?> clazz, Class<?>... paramTypes) {
Class<?>[] t = toPrimitiveTypeArray(paramTypes);
for (Method m : clazz.getMethods()) {
Class<?>[] types = toPrimitiveTypeArray(m.getParameterTypes());
if (m.getName().equals(name) && equalsTypeArray(types, t))
return m;
}
return null;
}
public static Object invokeMethod(String name, Class<?> clazz, Object obj, Object... args) throws Exception {
return getMethod(name, clazz, toPrimitiveTypeArray(args)).invoke(obj, args);
}
public static Field getField(String name, Class<?> clazz) throws Exception {
return clazz.getDeclaredField(name);
}
public static Object getValue(String name, Object obj) throws Exception {
Field f = getField(name, obj.getClass());
f.setAccessible(true);
return f.get(obj);
}
public static void setValue(Object obj, FieldEntry entry) throws Exception {
Field f = getField(entry.getKey(), obj.getClass());
f.setAccessible(true);
f.set(obj, entry.getValue());
}
public static void setValues(Object obj, FieldEntry... entrys) throws Exception {
for (FieldEntry f : entrys)
setValue(obj, f);
}
}