diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000..7c1125c --- /dev/null +++ b/.editorconfig @@ -0,0 +1,12 @@ +# Top-most EditorConfig file +root = true + +# Unix-style newlines with a newline ending every file +[*] +end_of_line = lf +insert_final_newline = true + +# Set the charset, and space indention +[*.java] +charset = utf-8 +indent_style = tab diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..37fa371 --- /dev/null +++ b/.gitignore @@ -0,0 +1,107 @@ +### Java files ### +*.class +MANIFEST.MF + +# Package Files +*.jar +*.war +*.ear + +# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml +hs_err_pid* + +# Mac OS +.DS_Store + +### Intellij ### +# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm +# Ignore project files +*.iml +*.java___jb_tmp___ + +# Ignore IDEA directory +.idea/* + +# Include the project's code style settings file +#!.idea/codeStyleSettings.xml + +# File-based project format: +*.ipr +*.iws + +### Plugin-specific files: ### +# IntelliJ +/out/ + +# mpeltonen/sbt-idea plugin +.idea_modules/ + +# JIRA plugin +atlassian-ide-plugin.xml + +# Crashlytics plugin (for Android Studio and IntelliJ) +com_crashlytics_export_strings.xml +crashlytics.properties +crashlytics-build.properties + +### Eclipse ### +*.pydevproject +.metadata +.gradle +bin/ +tmp/ +*.tmp +*.bak +*.swp +*~.nib +local.properties +.settings/ +.loadpath + +# Eclipse Core +.project + +# External tool builders +.externalToolBuilders/ + +# Locally stored "Eclipse launch configurations" +*.launch + +# CDT-specific +.cproject + +# JDT-specific (Eclipse Java Development Tools) +.classpath + +# PDT-specific +.buildpath + +# sbteclipse plugin +.target + +# TeXlipse plugin +.texlipse + +### Maven ### +target/ +pom.xml.tag +pom.xml.releaseBackup +pom.xml.versionsBackup +pom.xml.next +release.properties +dependency-reduced-pom.xml +buildNumber.properties + +### NetBeans ### +nbproject/private/ +build/ +nbbuild/ +dist/ +nbdist/ +nbactions.xml +nb-configuration.xml +.nb-gradle/ + +### Git ### +# Don't exclude the .gitignore itself +!.gitignore diff --git a/.travis.yml b/.travis.yml index b0a84a3..eafdcd1 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,19 +1,11 @@ +sudo: false language: java jdk: - oraclejdk8 -script: "mvn deploy --settings settings.xml" +script: "mvn clean package deploy --settings settings.xml" + env: global: - secure: "hKUxyzr5yj9u7JTOpN8r09P/8X9AJMiVvNvgERq+KIG7ngm3hsxODg/CQiB64ch3Rx3molO6g7qUBUTFa4/OiFqmCePxEF+ZpjGER+9tjpWA4Ot/EKWP+ERAuMg/2M7sPhjzfbV1UJfhEvRGNhThTdiThgXeTAG9DIpUAuaYTCfevFRJuFVaunqGN/f0nKNLEr95DkkYycgni2wye1sRRvcOM+shv/VM3YxwCUlUGEEuMlxaN0vvw13n/keu4Jr2qvfyw7750mqu2IqqTLeVpEZgZwb1bM8U2DcVKv6527fOCWQf1+c/3aPHXQnJly1TeS69k4WadefrVZbsA4y5NwX+vE8Ju+0zBSACWQTGGewZAzZIxIrh7m3VXMouvAdQckt8o4vea7Gq61coOXbNuY6rEdHGofEmrWZccjV0Hn8dpVDxTk7jAWxnO+TxOekdLI3mviqyi/Bfn/obqrGvreUOYoFhKyP9ZR2WWO2To0hyhDDyZxHdq1OPjMqeeFYqG40lDq7LvIhFKeT1zt+vR/X+oV04YuZ7/AyhFP0mwjSFeITf8rh7RmPaJrQxE/g3/aXTAEqGtwOUhsIfnAOAI0kiw1qQlNou+iGWwfXVjBX91dsARWXwD6AzMh9FQaQjh0wwj0Ue6H5+K0d9lK0UmWGVZU0O+sKLxulO4D3r2DM=" - secure: "GH3FtcvragmFD2wbXc9nOCHT4qp8P7aQ8KmSpRbAJ1LR+OkEjvOk1RZwkGjEzQ4AJGWhFHFX3WmFR/9si0ystdWEBI1pubL/L7o79q5l8H60Az90lrz8hmruGeZaVs5klFQBE8IWQ9BvR3n8OGCOIZCqDIshJIB1+3QX7X7vIK95M91ZPps4N5gRpwwU69pB1N16MKJ1BhzZQIWTvA+rB+x5lAlomjWJEwCGuT2d1ZkBjTex/sGEab816LbfOp4/6DvoOdO45FiqCebaSwO6j7Ejg7WV19Q2XLFN6GaFyESHW0hrpoAg96jWyJrKjEP9N0+l7MgwvweZ/cME8BVyA7mstLeqpJgLMlNTKoknKwOv0NNeUn4a64NwCzjkVziokncbCBiJLdw5r0usJqW7rbo9fmQI710asItJN56rqH+elsa1vDpzqSpEqBB3T5AW4VBvsMu5BFhEmC+9W5iMiUhqP/CMFW2+IJeGh4Shb2BNeUm2uelHTiQTogv4/7fK1UUM6opYz2OtFakZO288isg5r+jTrZYFAVVhq4tczyDDhF5fTw9lcpZmreVh/z0u0TemDXM44Iw3wsg8Hmyh+d3C9gDjknpprX3UAN2b2R82+cA43dW3x4rs5m/aHQ4rHuK4oMH0T57gSDtgxp01YjMPQ57Fus2Z8FKVnfhZ8KI=" -deploy: - provider: releases - api_key: - secure: "jA5sN5LpJJUUeTvSdsbAJqrvQvqo05dUeRQDEBgCYA8qDa4aEV0YOOEloscw6nNHSt1cU942oI50Xxp8Ykvfxk8FtRFj4COR3bjtLu2COF4jo/tVa7xcyQhh9dPe2srZkmb59CY5KdjwhMcnlk8B8F0p5ir3NWyoFtwEHeLbfRSCMhHqkwosmSM+V11k3+xG8RcZnTlfTqt/I1GnSoL7vUfLUt16IU5CSioomlW3SMJ0wCpb62iTyTQO7WWfRWa3Yl8kYp+nNXS+2zT1821eLAVH7LugZOs22y0OMu+Mka2uwWa5ylbEttqsJwe2ZTJP5fSDN20uyOcJFNLf67bD87BOEz73kl5E/dwJwvJe8XQtveSZ+LP+Iw1viOia8gYUnnI+l9JRGKNECurbY9QC2/5UjCzULw8NRyNjfLU1C+5htT+BNM+O+Oa6PWqvTONDJgR8dGl476vVJL8JLwfBtjrvMXAC3lqEAi4Y0j9eGOYWihSekfyWnPPiL+oyRUMqqhHLrvC+iKrEWpK+9p0hN9nQ6ugbHyi8o4+F+6iqlmoS/mH9P0hekEUJ5WybqcvncGFvKfMFmXVY3vjg2QoDwqNG4Z/K8phbDHGhcTyoFjpMTEnfJTuAEQTxPSslHvkdw7VjKSjyJ8yn0+Yt2SpsDMsINUtyrAsnui2tWbuS54w=" - file_glob: true - file: - - "target/ReflectionHelper_v*.jar" - skip_cleanup: true - on: - tags: true diff --git a/pom.xml b/pom.xml index a8c5f05..529c456 100644 --- a/pom.xml +++ b/pom.xml @@ -1,5 +1,4 @@ - @@ -7,85 +6,42 @@ org.inventivetalent reflectionhelper - 1.13.0-SNAPSHOT + 1.13.1-SNAPSHOT + + ReflectionHelper + API for accessing various classes and their members using reflection. + + + UTF-8 + - ReflectionHelper_v${project.version} - src/main/java - - - src/main/java - - **/*.java - - - - src/main/resources - true - - plugin.yml - config.yml - - - maven-compiler-plugin - 3.3 + 3.6.2 - 1.7 - 1.7 + true + -XDignore.symbol.file + 1.8 + 1.8 - - org.apache.maven.plugins - maven-shade-plugin - 2.4 - - - package - - shade - - - - - org.inventivetalent:reflectionhelper** - - - - - - + - - inventive-repo - http://repo.inventivetalent.org/content/groups/public/ - - - md_5-repo - http://repo.md-5.net/content/repositories/public/ - spigot-repo - https://hub.spigotmc.org/nexus/content/groups/public/ + https://hub.spigotmc.org/nexus/content/repositories/snapshots/ - - techcable-repo - http://repo.techcable.net/content/groups/public/ - - - - - + org.spigotmc spigot-api - 1.9-R0.1-SNAPSHOT + 1.12.2-R0.1-SNAPSHOT provided @@ -93,6 +49,7 @@ junit junit 4.12 + test @@ -106,4 +63,4 @@ http://repo.inventivetalent.org/content/repositories/snapshots/ - \ No newline at end of file + diff --git a/src/main/java/org/inventivetalent/reflection/annotation/Class.java b/src/main/java/org/inventivetalent/reflection/annotation/Class.java index 15761c5..f2a7068 100644 --- a/src/main/java/org/inventivetalent/reflection/annotation/Class.java +++ b/src/main/java/org/inventivetalent/reflection/annotation/Class.java @@ -12,6 +12,7 @@ */ @Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) +@SuppressWarnings("unused") public @interface Class { /** diff --git a/src/main/java/org/inventivetalent/reflection/annotation/Field.java b/src/main/java/org/inventivetalent/reflection/annotation/Field.java index 80430fe..bcd4760 100644 --- a/src/main/java/org/inventivetalent/reflection/annotation/Field.java +++ b/src/main/java/org/inventivetalent/reflection/annotation/Field.java @@ -12,6 +12,7 @@ */ @Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) +@SuppressWarnings("unused") public @interface Field { /** diff --git a/src/main/java/org/inventivetalent/reflection/annotation/Method.java b/src/main/java/org/inventivetalent/reflection/annotation/Method.java index ddd2513..a4352de 100644 --- a/src/main/java/org/inventivetalent/reflection/annotation/Method.java +++ b/src/main/java/org/inventivetalent/reflection/annotation/Method.java @@ -12,6 +12,7 @@ */ @Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) +@SuppressWarnings("unused") public @interface Method { /** diff --git a/src/main/java/org/inventivetalent/reflection/annotation/ReflectionAnnotations.java b/src/main/java/org/inventivetalent/reflection/annotation/ReflectionAnnotations.java index b2c34c3..98c31b2 100644 --- a/src/main/java/org/inventivetalent/reflection/annotation/ReflectionAnnotations.java +++ b/src/main/java/org/inventivetalent/reflection/annotation/ReflectionAnnotations.java @@ -10,21 +10,25 @@ import java.lang.annotation.Annotation; import java.util.ArrayList; +import java.util.Collections; import java.util.List; import java.util.regex.Matcher; import java.util.regex.Pattern; +@SuppressWarnings("unused") public class ReflectionAnnotations { public static final ReflectionAnnotations INSTANCE = new ReflectionAnnotations(); - static final Pattern classRefPattern = Pattern.compile("@Class\\((.*)\\)"); + private static final Pattern classRefPattern = Pattern.compile("@Class\\((.*)\\)"); private ReflectionAnnotations() { } public void load(Object toLoad) { - if (toLoad == null) { throw new IllegalArgumentException("toLoad cannot be null"); } + if (toLoad == null) { + throw new IllegalArgumentException("toLoad cannot be null"); + } ClassResolver classResolver = new ClassResolver(); @@ -41,7 +45,9 @@ public void load(Object toLoad) { if (classAnnotation != null) { List nameList = parseAnnotationVersions(Class.class, classAnnotation); - if (nameList.isEmpty()) { throw new IllegalArgumentException("@Class names cannot be empty"); } + if (nameList.isEmpty()) { + throw new IllegalArgumentException("@Class names cannot be empty"); + } String[] names = nameList.toArray(new String[nameList.size()]); for (int i = 0; i < names.length; i++) {// Replace NMS & OBC names[i] = names[i] @@ -65,7 +71,9 @@ public void load(Object toLoad) { } } else if (fieldAnnotation != null) { List nameList = parseAnnotationVersions(Field.class, fieldAnnotation); - if (nameList.isEmpty()) { throw new IllegalArgumentException("@Field names cannot be empty"); } + if (nameList.isEmpty()) { + throw new IllegalArgumentException("@Field names cannot be empty"); + } String[] names = nameList.toArray(new String[nameList.size()]); try { FieldResolver fieldResolver = new FieldResolver(parseClass(Field.class, fieldAnnotation, toLoad)); @@ -83,9 +91,11 @@ public void load(Object toLoad) { return; } } - } else if (methodAnnotation != null) { + } else { List nameList = parseAnnotationVersions(Method.class, methodAnnotation); - if (nameList.isEmpty()) { throw new IllegalArgumentException("@Method names cannot be empty"); } + if (nameList.isEmpty()) { + throw new IllegalArgumentException("@Method names cannot be empty"); + } String[] names = nameList.toArray(new String[nameList.size()]); boolean isSignature = names[0].contains(" ");// Only signatures can contain spaces (e.g. "void aMethod()") @@ -131,7 +141,7 @@ public void load(Object toLoad) { * @param annotation type * @return a list of matching names */ - List parseAnnotationVersions(java.lang.Class clazz, A annotation) { + private List parseAnnotationVersions(java.lang.Class clazz, A annotation) { List list = new ArrayList<>(); try { @@ -139,9 +149,7 @@ List parseAnnotationVersions(java.lang.Class c Minecraft.Version[] versions = (Minecraft.Version[]) clazz.getMethod("versions").invoke(annotation); if (versions.length == 0) {// No versions specified -> directly use the names - for (String name : names) { - list.add(name); - } + Collections.addAll(list, names); } else { if (versions.length > names.length) { throw new RuntimeException("versions array cannot have more elements than the names (" + clazz + ")"); @@ -165,12 +173,14 @@ List parseAnnotationVersions(java.lang.Class c return list; } - String parseClass(java.lang.Class clazz, A annotation, Object toLoad) { + private String parseClass(java.lang.Class clazz, A annotation, Object toLoad) { try { String className = (String) clazz.getMethod("className").invoke(annotation); Matcher matcher = classRefPattern.matcher(className); while (matcher.find()) { - if (matcher.groupCount() != 1) { continue; } + if (matcher.groupCount() != 1) { + continue; + } String fieldName = matcher.group(1);// It's a reference to a previously loaded class java.lang.reflect.Field field = toLoad.getClass().getField(fieldName); if (ClassWrapper.class.isAssignableFrom(field.getType())) { @@ -185,11 +195,11 @@ String parseClass(java.lang.Class clazz, A annotation, } } - void throwInvalidFieldType(java.lang.reflect.Field field, Object toLoad, String expected) { + private void throwInvalidFieldType(java.lang.reflect.Field field, Object toLoad, String expected) { throw new IllegalArgumentException("Field " + field.getName() + " in " + toLoad.getClass() + " is not of type " + expected + ", it's " + field.getType()); } - void throwReflectionException(String annotation, java.lang.reflect.Field field, Object toLoad, ReflectiveOperationException exception) { + private void throwReflectionException(String annotation, java.lang.reflect.Field field, Object toLoad, ReflectiveOperationException exception) { throw new RuntimeException("Failed to set " + annotation + " field " + field.getName() + " in " + toLoad.getClass(), exception); } diff --git a/src/main/java/org/inventivetalent/reflection/minecraft/DataWatcher.java b/src/main/java/org/inventivetalent/reflection/minecraft/DataWatcher.java index 09300ba..23ddb15 100644 --- a/src/main/java/org/inventivetalent/reflection/minecraft/DataWatcher.java +++ b/src/main/java/org/inventivetalent/reflection/minecraft/DataWatcher.java @@ -1,6 +1,9 @@ package org.inventivetalent.reflection.minecraft; -import org.inventivetalent.reflection.resolver.*; +import org.inventivetalent.reflection.resolver.ConstructorResolver; +import org.inventivetalent.reflection.resolver.FieldResolver; +import org.inventivetalent.reflection.resolver.MethodResolver; +import org.inventivetalent.reflection.resolver.ResolverQuery; import org.inventivetalent.reflection.resolver.minecraft.NMSClassResolver; import java.lang.reflect.Field; @@ -9,28 +12,32 @@ import java.util.Arrays; import java.util.Map; +@SuppressWarnings({"unused", "WeakerAccess"}) public class DataWatcher { - static ClassResolver classResolver = new ClassResolver(); - static NMSClassResolver nmsClassResolver = new NMSClassResolver(); + //private static ClassResolver classResolver = new ClassResolver(); + private static NMSClassResolver nmsClassResolver = new NMSClassResolver(); - static Class ItemStack = nmsClassResolver.resolveSilent("ItemStack"); - static Class ChunkCoordinates = nmsClassResolver.resolveSilent("ChunkCoordinates"); - static Class BlockPosition = nmsClassResolver.resolveSilent("BlockPosition"); - static Class Vector3f = nmsClassResolver.resolveSilent("Vector3f"); - static Class DataWatcher = nmsClassResolver.resolveSilent("DataWatcher"); - static Class Entity = nmsClassResolver.resolveSilent("Entity"); - static Class TIntObjectMap = classResolver.resolveSilent("gnu.trove.map.TIntObjectMap", "net.minecraft.util.gnu.trove.map.TIntObjectMap"); + private static Class ItemStack = nmsClassResolver.resolveSilent("ItemStack"); + private static Class ChunkCoordinates = nmsClassResolver.resolveSilent("ChunkCoordinates"); + private static Class BlockPosition = nmsClassResolver.resolveSilent("BlockPosition"); + private static Class Vector3f = nmsClassResolver.resolveSilent("Vector3f"); + private static Class DataWatcher = nmsClassResolver.resolveSilent("DataWatcher"); + private static Class Entity = nmsClassResolver.resolveSilent("Entity"); + //private static Class TIntObjectMap = classResolver.resolveSilent("gnu.trove.map.TIntObjectMap", "net.minecraft.util.gnu.trove.map.TIntObjectMap"); - static ConstructorResolver DataWacherConstructorResolver = new ConstructorResolver(DataWatcher); + private static ConstructorResolver DataWacherConstructorResolver = new ConstructorResolver(DataWatcher); - static FieldResolver DataWatcherFieldResolver = new FieldResolver(DataWatcher); + private static FieldResolver DataWatcherFieldResolver = new FieldResolver(DataWatcher); - static MethodResolver TIntObjectMapMethodResolver = new MethodResolver(TIntObjectMap); - static MethodResolver DataWatcherMethodResolver = new MethodResolver(DataWatcher); + //private static MethodResolver TIntObjectMapMethodResolver = new MethodResolver(TIntObjectMap); + private static MethodResolver DataWatcherMethodResolver = new MethodResolver(DataWatcher); + + private DataWatcher() { + } public static Object newDataWatcher(Object entity) throws ReflectiveOperationException { - return DataWacherConstructorResolver.resolve(new Class[] { Entity }).newInstance(entity); + return DataWacherConstructorResolver.resolve(new Class[]{Entity}).newInstance(entity); } public static Object setValue(Object dataWatcher, int index, Object dataWatcherObject/*1.9*/, Object value) throws ReflectiveOperationException { @@ -106,7 +113,7 @@ public static int getValueType(Object value) { */ public static class V1_9 { - static Class DataWatcherItem = nmsClassResolver.resolveSilent("DataWatcher$Item");//>= 1.9 only + static Class DataWatcherItem = nmsClassResolver.resolveSilent("DataWatcher$Item");//>= 1.9 only static Class DataWatcherObject = nmsClassResolver.resolveSilent("DataWatcherObject");//>= 1.9 only static ConstructorResolver DataWatcherItemConstructorResolver;//>=1.9 only @@ -115,7 +122,9 @@ public static class V1_9 { static FieldResolver DataWatcherObjectFieldResolver;//>=1.9 only public static Object newDataWatcherItem(Object dataWatcherObject, Object value) throws ReflectiveOperationException { - if (DataWatcherItemConstructorResolver == null) { DataWatcherItemConstructorResolver = new ConstructorResolver(DataWatcherItem); } + if (DataWatcherItemConstructorResolver == null) { + DataWatcherItemConstructorResolver = new ConstructorResolver(DataWatcherItem); + } return DataWatcherItemConstructorResolver.resolveFirstConstructor().newInstance(dataWatcherObject, value); } @@ -123,6 +132,7 @@ public static Object setItem(Object dataWatcher, int index, Object dataWatcherOb return setItem(dataWatcher, index, newDataWatcherItem(dataWatcherObject, value)); } + @SuppressWarnings("unchecked") public static Object setItem(Object dataWatcher, int index, Object dataWatcherItem) throws ReflectiveOperationException { Map map = (Map) DataWatcherFieldResolver.resolveByLastTypeSilent(Map.class).get(dataWatcher); map.put(index, dataWatcherItem); @@ -134,10 +144,10 @@ public static Object setValue(Object dataWatcher, Object dataWatcherObject, Obje return dataWatcher; } - // public static Object getValue(Object dataWatcher, int index) throws ReflectiveOperationException { - // Map map = (Map) DataWatcherFieldResolver.resolve("c").get(dataWatcher); - // return map.get(index); - // } + //public static Object getValue(Object dataWatcher, int index) throws ReflectiveOperationException { + // Map map = (Map) DataWatcherFieldResolver.resolve("c").get(dataWatcher); + // return map.get(index); + //} public static Object getItem(Object dataWatcher, Object dataWatcherObject) throws ReflectiveOperationException { return DataWatcherMethodResolver.resolve(new ResolverQuery("c", DataWatcherObject)).invoke(dataWatcher, dataWatcherObject); @@ -152,10 +162,13 @@ public static Object getValue(Object dataWatcher, ValueType type) throws Reflect } public static Object getItemObject(Object item) throws ReflectiveOperationException { - if (DataWatcherItemFieldResolver == null) { DataWatcherItemFieldResolver = new FieldResolver(DataWatcherItem); } + if (DataWatcherItemFieldResolver == null) { + DataWatcherItemFieldResolver = new FieldResolver(DataWatcherItem); + } return DataWatcherItemFieldResolver.resolve("a").get(item); } + @SuppressWarnings("unchecked") public static int getItemIndex(Object dataWatcher, Object item) throws ReflectiveOperationException { int index = -1;//Return -1 if the item is not in the DataWatcher Map map = (Map) DataWatcherFieldResolver.resolveByLastTypeSilent(Map.class).get(dataWatcher); @@ -169,7 +182,9 @@ public static int getItemIndex(Object dataWatcher, Object item) throws Reflectiv } public static Type getItemType(Object item) throws ReflectiveOperationException { - if (DataWatcherObjectFieldResolver == null) { DataWatcherObjectFieldResolver = new FieldResolver(DataWatcherObject); } + if (DataWatcherObjectFieldResolver == null) { + DataWatcherObjectFieldResolver = new FieldResolver(DataWatcherObject); + } Object object = getItemObject(item); Object serializer = DataWatcherObjectFieldResolver.resolve("b").get(object); Type[] genericInterfaces = serializer.getClass().getGenericInterfaces(); @@ -186,7 +201,9 @@ public static Type getItemType(Object item) throws ReflectiveOperationException } public static Object getItemValue(Object item) throws ReflectiveOperationException { - if (DataWatcherItemFieldResolver == null) { DataWatcherItemFieldResolver = new FieldResolver(DataWatcherItem); } + if (DataWatcherItemFieldResolver == null) { + DataWatcherItemFieldResolver = new FieldResolver(DataWatcherItem); + } return DataWatcherItemFieldResolver.resolve("b").get(item); } @@ -368,13 +385,16 @@ public static Object newWatchableObject(int index, Object value) throws Reflecti } public static Object newWatchableObject(int type, int index, Object value) throws ReflectiveOperationException { - if (WatchableObjectConstructorResolver == null) { WatchableObjectConstructorResolver = new ConstructorResolver(WatchableObject); } - return WatchableObjectConstructorResolver.resolve(new Class[] { + if (WatchableObjectConstructorResolver == null) { + WatchableObjectConstructorResolver = new ConstructorResolver(WatchableObject); + } + return WatchableObjectConstructorResolver.resolve(new Class[]{ int.class, int.class, - Object.class }).newInstance(type, index, value); + Object.class}).newInstance(type, index, value); } + @SuppressWarnings("unchecked") public static Object setValue(Object dataWatcher, int index, Object value) throws ReflectiveOperationException { int type = getValueType(value); @@ -391,22 +411,25 @@ public static Object getValue(Object dataWatcher, int index) throws ReflectiveOp } public static int getWatchableObjectIndex(Object object) throws ReflectiveOperationException { - if (WatchableObjectFieldResolver == null) { WatchableObjectFieldResolver = new FieldResolver(WatchableObject); } + if (WatchableObjectFieldResolver == null) { + WatchableObjectFieldResolver = new FieldResolver(WatchableObject); + } return WatchableObjectFieldResolver.resolve("b").getInt(object); } public static int getWatchableObjectType(Object object) throws ReflectiveOperationException { - if (WatchableObjectFieldResolver == null) { WatchableObjectFieldResolver = new FieldResolver(WatchableObject); } + if (WatchableObjectFieldResolver == null) { + WatchableObjectFieldResolver = new FieldResolver(WatchableObject); + } return WatchableObjectFieldResolver.resolve("a").getInt(object); } public static Object getWatchableObjectValue(Object object) throws ReflectiveOperationException { - if (WatchableObjectFieldResolver == null) { WatchableObjectFieldResolver = new FieldResolver(WatchableObject); } + if (WatchableObjectFieldResolver == null) { + WatchableObjectFieldResolver = new FieldResolver(WatchableObject); + } return WatchableObjectFieldResolver.resolve("c").get(object); } } - - private DataWatcher() { - } } diff --git a/src/main/java/org/inventivetalent/reflection/minecraft/Minecraft.java b/src/main/java/org/inventivetalent/reflection/minecraft/Minecraft.java index 03462f8..5c1e70b 100644 --- a/src/main/java/org/inventivetalent/reflection/minecraft/Minecraft.java +++ b/src/main/java/org/inventivetalent/reflection/minecraft/Minecraft.java @@ -19,11 +19,10 @@ /** * Helper class to access minecraft/bukkit specific objects */ +@SuppressWarnings({"unused", "WeakerAccess"}) public class Minecraft { - static final Pattern NUMERIC_VERSION_PATTERN = Pattern.compile("v([0-9])_([0-9]*)_R([0-9])"); - public static final Version VERSION; - + static final Pattern NUMERIC_VERSION_PATTERN = Pattern.compile("v([0-9])_([0-9]*)_R([0-9])"); private static NMSClassResolver nmsClassResolver = new NMSClassResolver(); private static OBCClassResolver obcClassResolver = new OBCClassResolver(); private static Class NmsEntity; @@ -71,11 +70,23 @@ public static Entity getBukkitEntity(Object object) throws ReflectiveOperationEx public static Object getHandleSilent(Object object) { try { return getHandle(object); - } catch (Exception e) { + } catch (Exception ignored) { } return null; } + public static Object newEnumInstance(Class clazz, Class[] types, Object[] values) throws ReflectiveOperationException { + Constructor constructor = new ConstructorResolver(clazz).resolve(types); + Field accessorField = new FieldResolver(Constructor.class).resolve("constructorAccessor"); + ConstructorAccessor constructorAccessor = (ConstructorAccessor) accessorField.get(constructor); + if (constructorAccessor == null) { + new MethodResolver(Constructor.class).resolve("acquireConstructorAccessor").invoke(constructor); + constructorAccessor = (ConstructorAccessor) accessorField.get(constructor); + } + return constructorAccessor.newInstance(values); + + } + public enum Version { UNKNOWN(-1) { @Override @@ -101,7 +112,7 @@ public boolean matchesPackageName(String packageName) { v1_10_R1(11001), v1_11_R1(11101), - + v1_12_R1(11201); private int version; @@ -110,60 +121,32 @@ public boolean matchesPackageName(String packageName) { this.version = version; } - /** - * @return the version-number - */ - public int version() { - return version; - } - - /** - * @param version the version to check - * @return true if this version is older than the specified version - */ - public boolean olderThan(Version version) { - return version() < version.version(); - } - - /** - * @param version the version to check - * @return true if this version is newer than the specified version - */ - public boolean newerThan(Version version) { - return version() >= version.version(); - } - - /** - * @param oldVersion The older version to check - * @param newVersion The newer version to check - * @return true if this version is newer than the oldVersion and older that the newVersion - */ - public boolean inRange(Version oldVersion, Version newVersion) { - return newerThan(oldVersion) && olderThan(newVersion); - } - - public boolean matchesPackageName(String packageName) { - return packageName.toLowerCase().contains(name().toLowerCase()); - } - public static Version getVersion() { String name = Bukkit.getServer().getClass().getPackage().getName(); String versionPackage = name.substring(name.lastIndexOf('.') + 1) + "."; for (Version version : values()) { - if (version.matchesPackageName(versionPackage)) { return version; } + if (version.matchesPackageName(versionPackage)) { + return version; + } } System.err.println("[ReflectionHelper] Failed to find version enum for '" + name + "'/'" + versionPackage + "'"); System.out.println("[ReflectionHelper] Generating dynamic constant..."); Matcher matcher = NUMERIC_VERSION_PATTERN.matcher(versionPackage); while (matcher.find()) { - if (matcher.groupCount() < 3) { continue; } + if (matcher.groupCount() < 3) { + continue; + } String majorString = matcher.group(1); String minorString = matcher.group(2); - if (minorString.length() == 1) { minorString = "0" + minorString; } + if (minorString.length() == 1) { + minorString = "0" + minorString; + } String patchString = matcher.group(3); - if (patchString.length() == 1) { patchString = "0" + patchString; } + if (patchString.length() == 1) { + patchString = "0" + patchString; + } String numVersionString = majorString + minorString + patchString; int numVersion = Integer.parseInt(numVersionString); @@ -175,13 +158,13 @@ public static Version getVersion() { Version[] oldValues = (Version[]) valuesField.get(null); Version[] newValues = new Version[oldValues.length + 1]; System.arraycopy(oldValues, 0, newValues, 0, oldValues.length); - Version dynamicVersion = (Version) newEnumInstance(Version.class, new Class[] { + Version dynamicVersion = (Version) newEnumInstance(Version.class, new Class[]{ String.class, int.class, - int.class }, new Object[] { + int.class}, new Object[]{ packge, newValues.length - 1, - numVersion }); + numVersion}); newValues[newValues.length - 1] = dynamicVersion; valuesField.set(null, newValues); @@ -196,22 +179,46 @@ public static Version getVersion() { return UNKNOWN; } - @Override - public String toString() { - return name() + " (" + version() + ")"; + /** + * @return the version-number + */ + public int version() { + return version; } - } - public static Object newEnumInstance(Class clazz, Class[] types, Object[] values) throws ReflectiveOperationException { - Constructor constructor = new ConstructorResolver(clazz).resolve(types); - Field accessorField = new FieldResolver(Constructor.class).resolve("constructorAccessor"); - ConstructorAccessor constructorAccessor = (ConstructorAccessor) accessorField.get(constructor); - if (constructorAccessor == null) { - new MethodResolver(Constructor.class).resolve("acquireConstructorAccessor").invoke(constructor); - constructorAccessor = (ConstructorAccessor) accessorField.get(constructor); + /** + * @param version the version to check + * @return true if this version is older than the specified version + */ + public boolean olderThan(Version version) { + return version() < version.version(); + } + + /** + * @param version the version to check + * @return true if this version is newer than the specified version + */ + public boolean newerThan(Version version) { + return version() >= version.version(); + } + + /** + * @param oldVersion The older version to check + * @param newVersion The newer version to check + * @return true if this version is newer than the oldVersion and older that the newVersion + */ + public boolean inRange(Version oldVersion, Version newVersion) { + return newerThan(oldVersion) && olderThan(newVersion); } - return constructorAccessor.newInstance(values); + public boolean matchesPackageName(String packageName) { + return packageName.toLowerCase().contains(name().toLowerCase()); + } + + @Override + public String toString() { + return name() + " (" + version() + ")"; + } } } diff --git a/src/main/java/org/inventivetalent/reflection/resolver/ClassResolver.java b/src/main/java/org/inventivetalent/reflection/resolver/ClassResolver.java index 1f1cc40..a1a598e 100644 --- a/src/main/java/org/inventivetalent/reflection/resolver/ClassResolver.java +++ b/src/main/java/org/inventivetalent/reflection/resolver/ClassResolver.java @@ -7,6 +7,7 @@ */ public class ClassResolver extends ResolverAbstract { + @SuppressWarnings("unchecked") public ClassWrapper resolveWrapper(String... names) { return new ClassWrapper<>(resolveSilent(names)); } @@ -14,7 +15,7 @@ public ClassWrapper resolveWrapper(String... names) { public Class resolveSilent(String... names) { try { return resolve(names); - } catch (Exception e) { + } catch (Exception ignored) { } return null; } diff --git a/src/main/java/org/inventivetalent/reflection/resolver/ConstructorResolver.java b/src/main/java/org/inventivetalent/reflection/resolver/ConstructorResolver.java index fd24261..0f4d34b 100644 --- a/src/main/java/org/inventivetalent/reflection/resolver/ConstructorResolver.java +++ b/src/main/java/org/inventivetalent/reflection/resolver/ConstructorResolver.java @@ -8,6 +8,8 @@ /** * Resolver for constructors */ + +@SuppressWarnings({"unused", "WeakerAccess"}) public class ConstructorResolver extends MemberResolver { public ConstructorResolver(Class clazz) { @@ -33,10 +35,12 @@ public Constructor resolveIndexSilent(int index) { } @Override + @SuppressWarnings("unchecked") public ConstructorWrapper resolveIndexWrapper(int index) { return new ConstructorWrapper<>(resolveIndexSilent(index)); } + @SuppressWarnings("unchecked") public ConstructorWrapper resolveWrapper(Class[]... types) { return new ConstructorWrapper<>(resolveSilent(types)); } @@ -44,7 +48,7 @@ public ConstructorWrapper resolveWrapper(Class[]... types) { public Constructor resolveSilent(Class[]... types) { try { return resolve(types); - } catch (Exception e) { + } catch (Exception ignored) { } return null; } @@ -75,7 +79,7 @@ public Constructor resolveFirstConstructor() throws ReflectiveOperationException public Constructor resolveFirstConstructorSilent() { try { return resolveFirstConstructor(); - } catch (Exception e) { + } catch (Exception ignored) { } return null; } @@ -85,14 +89,16 @@ public Constructor resolveLastConstructor() throws ReflectiveOperationException for (Constructor constructor1 : this.clazz.getDeclaredConstructors()) { constructor = constructor1; } - if (constructor != null) { return AccessUtil.setAccessible(constructor); } + if (constructor != null) { + return AccessUtil.setAccessible(constructor); + } return null; } public Constructor resolveLastConstructorSilent() { try { return resolveLastConstructor(); - } catch (Exception e) { + } catch (Exception ignored) { } return null; } diff --git a/src/main/java/org/inventivetalent/reflection/resolver/FieldResolver.java b/src/main/java/org/inventivetalent/reflection/resolver/FieldResolver.java index ed63bd6..1a09339 100644 --- a/src/main/java/org/inventivetalent/reflection/resolver/FieldResolver.java +++ b/src/main/java/org/inventivetalent/reflection/resolver/FieldResolver.java @@ -8,6 +8,7 @@ /** * Resolver for fields */ +@SuppressWarnings({"unused", "WeakerAccess"}) public class FieldResolver extends MemberResolver { public FieldResolver(Class clazz) { @@ -44,7 +45,7 @@ public FieldWrapper resolveWrapper(String... names) { public Field resolveSilent(String... names) { try { return resolve(names); - } catch (Exception e) { + } catch (Exception ignored) { } return null; } @@ -63,7 +64,7 @@ public Field resolve(String... names) throws NoSuchFieldException { public Field resolveSilent(ResolverQuery... queries) { try { return resolve(queries); - } catch (Exception e) { + } catch (Exception ignored) { } return null; } @@ -121,7 +122,7 @@ public Field resolveByFirstType(Class type) throws ReflectiveOperationExcepti public Field resolveByFirstTypeSilent(Class type) { try { return resolveByFirstType(type); - } catch (Exception e) { + } catch (Exception ignored) { } return null; } @@ -141,14 +142,16 @@ public Field resolveByLastType(Class type) throws ReflectiveOperationExceptio field = field1; } } - if (field == null) { throw new NoSuchFieldException("Could not resolve field of type '" + type.toString() + "' in class " + this.clazz); } + if (field == null) { + throw new NoSuchFieldException("Could not resolve field of type '" + type.toString() + "' in class " + this.clazz); + } return AccessUtil.setAccessible(field); } public Field resolveByLastTypeSilent(Class type) { try { return resolveByLastType(type); - } catch (Exception e) { + } catch (Exception ignored) { } return null; } diff --git a/src/main/java/org/inventivetalent/reflection/resolver/MemberResolver.java b/src/main/java/org/inventivetalent/reflection/resolver/MemberResolver.java index 8913ecd..df864e4 100644 --- a/src/main/java/org/inventivetalent/reflection/resolver/MemberResolver.java +++ b/src/main/java/org/inventivetalent/reflection/resolver/MemberResolver.java @@ -12,12 +12,16 @@ * @see FieldResolver * @see MethodResolver */ + +@SuppressWarnings({"unused", "WeakerAccess"}) public abstract class MemberResolver extends ResolverAbstract { protected Class clazz; public MemberResolver(Class clazz) { - if (clazz == null) { throw new IllegalArgumentException("class cannot be null"); } + if (clazz == null) { + throw new IllegalArgumentException("class cannot be null"); + } this.clazz = clazz; } diff --git a/src/main/java/org/inventivetalent/reflection/resolver/MethodResolver.java b/src/main/java/org/inventivetalent/reflection/resolver/MethodResolver.java index f378425..3e8aeeb 100644 --- a/src/main/java/org/inventivetalent/reflection/resolver/MethodResolver.java +++ b/src/main/java/org/inventivetalent/reflection/resolver/MethodResolver.java @@ -8,6 +8,7 @@ /** * Resolver for methods */ +@SuppressWarnings({"unused", "WeakerAccess"}) public class MethodResolver extends MemberResolver { public MethodResolver(Class clazz) { @@ -18,7 +19,21 @@ public MethodResolver(String className) throws ClassNotFoundException { super(className); } - public Method resolveSignature(String... signatures)throws ReflectiveOperationException { + static boolean ClassListEqual(Class[] l1, Class[] l2) { + boolean equal = true; + if (l1.length != l2.length) { + return false; + } + for (int i = 0; i < l1.length; i++) { + if (l1[i] != l2[i]) { + equal = false; + break; + } + } + return equal; + } + + public Method resolveSignature(String... signatures) throws ReflectiveOperationException { for (Method method : clazz.getDeclaredMethods()) { String methodSignature = MethodWrapper.getMethodSignature(method); for (String s : signatures) { @@ -72,7 +87,7 @@ public MethodWrapper resolveWrapper(ResolverQuery... queries) { public Method resolveSilent(String... names) { try { return resolve(names); - } catch (Exception e) { + } catch (Exception ignored) { } return null; } @@ -113,16 +128,4 @@ protected Method resolveObject(ResolverQuery query) throws ReflectiveOperationEx protected NoSuchMethodException notFoundException(String joinedNames) { return new NoSuchMethodException("Could not resolve method for " + joinedNames + " in class " + this.clazz); } - - static boolean ClassListEqual(Class[] l1, Class[] l2) { - boolean equal = true; - if (l1.length != l2.length) { return false; } - for (int i = 0; i < l1.length; i++) { - if (l1[i] != l2[i]) { - equal = false; - break; - } - } - return equal; - } } diff --git a/src/main/java/org/inventivetalent/reflection/resolver/ResolverAbstract.java b/src/main/java/org/inventivetalent/reflection/resolver/ResolverAbstract.java index a438a6b..7b132ff 100644 --- a/src/main/java/org/inventivetalent/reflection/resolver/ResolverAbstract.java +++ b/src/main/java/org/inventivetalent/reflection/resolver/ResolverAbstract.java @@ -13,6 +13,7 @@ * @see FieldResolver * @see MethodResolver */ +@SuppressWarnings({"unused", "WeakerAccess"}) public abstract class ResolverAbstract { protected final Map resolvedObjects = new ConcurrentHashMap(); @@ -26,7 +27,7 @@ public abstract class ResolverAbstract { protected T resolveSilent(ResolverQuery... queries) { try { return resolve(queries); - } catch (Exception e) { + } catch (Exception ignored) { } return null; } @@ -40,10 +41,14 @@ protected T resolveSilent(ResolverQuery... queries) { * @throws IllegalArgumentException if the given possibilities are empty */ protected T resolve(ResolverQuery... queries) throws ReflectiveOperationException { - if (queries == null || queries.length <= 0) { throw new IllegalArgumentException("Given possibilities are empty"); } + if (queries == null || queries.length <= 0) { + throw new IllegalArgumentException("Given possibilities are empty"); + } for (ResolverQuery query : queries) { //Object is already resolved, return it directly - if (resolvedObjects.containsKey(query)) { return resolvedObjects.get(query); } + if (resolvedObjects.containsKey(query)) { + return resolvedObjects.get(query); + } //Object is not yet resolved, try to find it try { diff --git a/src/main/java/org/inventivetalent/reflection/resolver/ResolverQuery.java b/src/main/java/org/inventivetalent/reflection/resolver/ResolverQuery.java index 599ebbc..5a4321f 100644 --- a/src/main/java/org/inventivetalent/reflection/resolver/ResolverQuery.java +++ b/src/main/java/org/inventivetalent/reflection/resolver/ResolverQuery.java @@ -9,9 +9,10 @@ * * @see org.inventivetalent.reflection.resolver.ResolverQuery.Builder */ +@SuppressWarnings({"unused", "WeakerAccess"}) public class ResolverQuery { - private String name; + private String name; private Class[] types; public ResolverQuery(String name, Class... types) { @@ -28,6 +29,10 @@ public ResolverQuery(Class... types) { this.types = types; } + public static Builder builder() { + return new Builder(); + } + public String getName() { return name; } @@ -38,12 +43,18 @@ public Class[] getTypes() { @Override public boolean equals(Object o) { - if (this == o) { return true; } - if (o == null || getClass() != o.getClass()) { return false; } + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } ResolverQuery that = (ResolverQuery) o; - if (name != null ? !name.equals(that.name) : that.name != null) { return false; } + if (name != null ? !name.equals(that.name) : that.name != null) { + return false; + } // Probably incorrect - comparing Object[] arrays with Arrays.equals return Arrays.equals(types, that.types); @@ -64,16 +75,12 @@ public String toString() { '}'; } - public static Builder builder() { - return new Builder(); - } - /** * Builder class for {@link ResolverQuery} Access using {@link ResolverQuery#builder()} */ public static class Builder { - private List queryList = new ArrayList(); + private List queryList = new ArrayList<>(); private Builder() { } diff --git a/src/main/java/org/inventivetalent/reflection/resolver/wrapper/ClassWrapper.java b/src/main/java/org/inventivetalent/reflection/resolver/wrapper/ClassWrapper.java index 342584c..aa94dd1 100644 --- a/src/main/java/org/inventivetalent/reflection/resolver/wrapper/ClassWrapper.java +++ b/src/main/java/org/inventivetalent/reflection/resolver/wrapper/ClassWrapper.java @@ -1,5 +1,6 @@ package org.inventivetalent.reflection.resolver.wrapper; +@SuppressWarnings({"unused", "WeakerAccess"}) public class ClassWrapper extends WrapperAbstract { private final Class clazz; @@ -32,15 +33,19 @@ public R newInstance() { public R newInstanceSilent() { try { return this.clazz.newInstance(); - } catch (Exception e) { + } catch (Exception ignored) { } return null; } @Override public boolean equals(Object object) { - if (this == object) { return true; } - if (object == null || getClass() != object.getClass()) { return false; } + if (this == object) { + return true; + } + if (object == null || getClass() != object.getClass()) { + return false; + } ClassWrapper that = (ClassWrapper) object; diff --git a/src/main/java/org/inventivetalent/reflection/resolver/wrapper/ConstructorWrapper.java b/src/main/java/org/inventivetalent/reflection/resolver/wrapper/ConstructorWrapper.java index 254bb48..9a6d152 100644 --- a/src/main/java/org/inventivetalent/reflection/resolver/wrapper/ConstructorWrapper.java +++ b/src/main/java/org/inventivetalent/reflection/resolver/wrapper/ConstructorWrapper.java @@ -2,6 +2,7 @@ import java.lang.reflect.Constructor; +@SuppressWarnings({"unused", "WeakerAccess"}) public class ConstructorWrapper extends WrapperAbstract { private final Constructor constructor; @@ -26,7 +27,7 @@ public R newInstance(Object... args) { public R newInstanceSilent(Object... args) { try { return this.constructor.newInstance(args); - } catch (Exception e) { + } catch (Exception ignored) { } return null; } @@ -41,8 +42,12 @@ public Constructor getConstructor() { @Override public boolean equals(Object object) { - if (this == object) { return true; } - if (object == null || getClass() != object.getClass()) { return false; } + if (this == object) { + return true; + } + if (object == null || getClass() != object.getClass()) { + return false; + } ConstructorWrapper that = (ConstructorWrapper) object; diff --git a/src/main/java/org/inventivetalent/reflection/resolver/wrapper/FieldWrapper.java b/src/main/java/org/inventivetalent/reflection/resolver/wrapper/FieldWrapper.java index ea4c439..8d2a667 100644 --- a/src/main/java/org/inventivetalent/reflection/resolver/wrapper/FieldWrapper.java +++ b/src/main/java/org/inventivetalent/reflection/resolver/wrapper/FieldWrapper.java @@ -2,6 +2,7 @@ import java.lang.reflect.Field; +@SuppressWarnings({"unused", "WeakerAccess"}) public class FieldWrapper extends WrapperAbstract { private final Field field; @@ -19,6 +20,7 @@ public String getName() { return this.field.getName(); } + @SuppressWarnings("unchecked") public R get(Object object) { try { return (R) this.field.get(object); @@ -27,10 +29,11 @@ public R get(Object object) { } } + @SuppressWarnings("unchecked") public R getSilent(Object object) { try { return (R) this.field.get(object); - } catch (Exception e) { + } catch (Exception ignored) { } return null; } @@ -46,7 +49,7 @@ public void set(Object object, R value) { public void setSilent(Object object, R value) { try { this.field.set(object, value); - } catch (Exception e) { + } catch (Exception ignored) { } } @@ -56,14 +59,16 @@ public Field getField() { @Override public boolean equals(Object object) { - if (this == object) { return true; } - if (object == null || getClass() != object.getClass()) { return false; } + if (this == object) { + return true; + } + if (object == null || getClass() != object.getClass()) { + return false; + } FieldWrapper that = (FieldWrapper) object; - if (field != null ? !field.equals(that.field) : that.field != null) { return false; } - - return true; + return field != null ? field.equals(that.field) : that.field == null; } @Override diff --git a/src/main/java/org/inventivetalent/reflection/resolver/wrapper/MethodWrapper.java b/src/main/java/org/inventivetalent/reflection/resolver/wrapper/MethodWrapper.java index 888c12b..3225132 100644 --- a/src/main/java/org/inventivetalent/reflection/resolver/wrapper/MethodWrapper.java +++ b/src/main/java/org/inventivetalent/reflection/resolver/wrapper/MethodWrapper.java @@ -5,6 +5,7 @@ import java.util.regex.Matcher; import java.util.regex.Pattern; +@SuppressWarnings({"unused", "WeakerAccess"}) public class MethodWrapper extends WrapperAbstract { private final Method method; @@ -13,51 +14,6 @@ public MethodWrapper(Method method) { this.method = method; } - @Override - public boolean exists() { - return this.method != null; - } - - public String getName() { - return this.method.getName(); - } - - public R invoke(Object object, Object... args) { - try { - return (R) this.method.invoke(object, args); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - public R invokeSilent(Object object, Object... args) { - try { - return (R) this.method.invoke(object, args); - } catch (Exception e) { - } - return null; - } - - public Method getMethod() { - return method; - } - - @Override - public boolean equals(Object object) { - if (this == object) { return true; } - if (object == null || getClass() != object.getClass()) { return false; } - - MethodWrapper that = (MethodWrapper) object; - - return method != null ? method.equals(that.method) : that.method == null; - - } - - @Override - public int hashCode() { - return method != null ? method.hashCode() : 0; - } - /** * Generates a method's signature. * @@ -99,15 +55,65 @@ public static String getMethodSignature(Method method) { return getMethodSignature(method, false); } + @Override + public boolean exists() { + return this.method != null; + } + + public String getName() { + return this.method.getName(); + } + + @SuppressWarnings("unchecked") + public R invoke(Object object, Object... args) { + try { + return (R) this.method.invoke(object, args); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + + @SuppressWarnings("unchecked") + public R invokeSilent(Object object, Object... args) { + try { + return (R) this.method.invoke(object, args); + } catch (Exception ignored) { + } + return null; + } + + public Method getMethod() { + return method; + } + + @Override + public boolean equals(Object object) { + if (this == object) { + return true; + } + if (object == null || getClass() != object.getClass()) { + return false; + } + + MethodWrapper that = (MethodWrapper) object; + + return method != null ? method.equals(that.method) : that.method == null; + } + + @Override + public int hashCode() { + return method != null ? method.hashCode() : 0; + } + public static class MethodSignature { static final Pattern SIGNATURE_STRING_PATTERN = Pattern.compile("(.+) (.*)\\((.*)\\)"); - private final String returnType; - private final Pattern returnTypePattern; - private final String name; - private final Pattern namePattern; + private final String returnType; + private final Pattern returnTypePattern; + private final String name; + private final Pattern namePattern; private final String[] parameterTypes; - private final String signature; + private final String signature; public MethodSignature(String returnType, String name, String[] parameterTypes) { this.returnType = returnType; @@ -153,7 +159,9 @@ public static MethodSignature of(Method method, boolean fullClassNames) { } public static MethodSignature fromString(String signatureString) { - if (signatureString == null) { return null; } + if (signatureString == null) { + return null; + } Matcher matcher = SIGNATURE_STRING_PATTERN.matcher(signatureString); if (matcher.find()) { if (matcher.groupCount() != 3) { @@ -204,20 +212,22 @@ public String getSignature() { * @return whether the signatures match */ public boolean matches(MethodSignature other) { - if (other == null) { return false; } - - // if (!returnType.equals(other.returnType)) { - // if (!isReturnTypeWildcard()) { return false; } - // } - // if (!name.equals(other.name)) { - // if (!isNameWildcard()) { return false; } - // } - // if (parameterTypes.length != other.parameterTypes.length) { return false; } - // for (int i = 0; i < parameterTypes.length; i++) { - // if (!getParameterType(i).equals(other.getParameterType(i))) { - // if (!isParameterWildcard(i)) { return false; } - // } - // } + if (other == null) { + return false; + } + + //if (!returnType.equals(other.returnType)) { + // if (!isReturnTypeWildcard()) { return false; } + //} + //if (!name.equals(other.name)) { + // if (!isNameWildcard()) { return false; } + //} + //if (parameterTypes.length != other.parameterTypes.length) { return false; } + //for (int i = 0; i < parameterTypes.length; i++) { + // if (!getParameterType(i).equals(other.getParameterType(i))) { + // if (!isParameterWildcard(i)) { return false; } + // } + //} if (!returnTypePattern.matcher(other.returnType).matches()) { return false; @@ -225,7 +235,9 @@ public boolean matches(MethodSignature other) { if (!namePattern.matcher(other.name).matches()) { return false; } - if (parameterTypes.length != other.parameterTypes.length) { return false; } + if (parameterTypes.length != other.parameterTypes.length) { + return false; + } for (int i = 0; i < parameterTypes.length; i++) { if (!Pattern.compile(getParameterType(i).replace("?", "\\w").replace("*", "\\w*")).matcher(other.getParameterType(i)).matches()) { return false; @@ -237,16 +249,23 @@ public boolean matches(MethodSignature other) { @Override public boolean equals(Object o) { - if (this == o) { return true; } - if (o == null || getClass() != o.getClass()) { return false; } + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } MethodSignature signature1 = (MethodSignature) o; - if (!returnType.equals(signature1.returnType)) { return false; } - if (!name.equals(signature1.name)) { return false; } + if (!returnType.equals(signature1.returnType)) { + return false; + } + if (!name.equals(signature1.name)) { + return false; + } // Probably incorrect - comparing Object[] arrays with Arrays.equals - if (!Arrays.equals(parameterTypes, signature1.parameterTypes)) { return false; } - return signature.equals(signature1.signature); + return Arrays.equals(parameterTypes, signature1.parameterTypes) && signature.equals(signature1.signature); } diff --git a/src/main/java/org/inventivetalent/reflection/util/AccessUtil.java b/src/main/java/org/inventivetalent/reflection/util/AccessUtil.java index 3ac2957..c1b61c0 100644 --- a/src/main/java/org/inventivetalent/reflection/util/AccessUtil.java +++ b/src/main/java/org/inventivetalent/reflection/util/AccessUtil.java @@ -9,12 +9,15 @@ */ public abstract class AccessUtil { + private AccessUtil() { + } + /** * Sets the field accessible and removes final modifiers * * @param field Field to set accessible * @return the Field - * @throws ReflectiveOperationException (usually never) + * @throws ReflectiveOperationException (usually never) */ public static Field setAccessible(Field field) throws ReflectiveOperationException { field.setAccessible(true); @@ -29,7 +32,7 @@ public static Field setAccessible(Field field) throws ReflectiveOperationExcepti * * @param method Method to set accessible * @return the Method - * @throws ReflectiveOperationException (usually never) + * @throws ReflectiveOperationException (usually never) */ public static Method setAccessible(Method method) throws ReflectiveOperationException { method.setAccessible(true); @@ -41,7 +44,7 @@ public static Method setAccessible(Method method) throws ReflectiveOperationExce * * @param constructor Constructor to set accessible * @return the Constructor - * @throws ReflectiveOperationException (usually never) + * @throws ReflectiveOperationException (usually never) */ public static Constructor setAccessible(Constructor constructor) throws ReflectiveOperationException { constructor.setAccessible(true); diff --git a/src/test/java/org/inventivetalent/reflectionhelper/test/Test.java b/src/test/java/org/inventivetalent/reflection/ReflectionTest.java similarity index 67% rename from src/test/java/org/inventivetalent/reflectionhelper/test/Test.java rename to src/test/java/org/inventivetalent/reflection/ReflectionTest.java index 57dcf08..7593f2c 100644 --- a/src/test/java/org/inventivetalent/reflectionhelper/test/Test.java +++ b/src/test/java/org/inventivetalent/reflection/ReflectionTest.java @@ -1,12 +1,14 @@ -package org.inventivetalent.reflectionhelper.test; +package org.inventivetalent.reflection; import org.inventivetalent.reflection.resolver.wrapper.MethodWrapper; +import org.junit.Test; import java.lang.reflect.Method; import static org.junit.Assert.*; -public class Test { +@SuppressWarnings({"unused", "WeakerAccess"}) +public class ReflectionTest { public double primitiveDummyMethod(String aString, double returnValue) { return returnValue; @@ -35,41 +37,41 @@ public int wildCardMethod4(String string) { return 0; } - @org.junit.Test + @Test public void primitiveSignatureTest() throws ReflectiveOperationException { - String signature = MethodWrapper.getMethodSignature(Test.class.getMethod("primitiveDummyMethod", String.class, double.class)); + String signature = MethodWrapper.getMethodSignature(ReflectionTest.class.getMethod("primitiveDummyMethod", String.class, double.class)); assertEquals("double primitiveDummyMethod(String,double)", signature); } - @org.junit.Test + @Test public void genericSignatureTest() throws ReflectiveOperationException { - String signature = MethodWrapper.getMethodSignature(Test.class.getMethod("genericDummyMethod", Thread.class, Exception.class)); + String signature = MethodWrapper.getMethodSignature(ReflectionTest.class.getMethod("genericDummyMethod", Thread.class, Exception.class)); assertEquals("Method genericDummyMethod(Thread,Exception)", signature); } - @org.junit.Test + @Test public void voidSignatureTest() throws ReflectiveOperationException { - String signature = MethodWrapper.getMethodSignature(Test.class.getMethod("voidDummyMethod", Character.class, Class.class, String.class)); + String signature = MethodWrapper.getMethodSignature(ReflectionTest.class.getMethod("voidDummyMethod", Character.class, Class.class, String.class)); assertEquals("void voidDummyMethod(Character,Class,String)", signature); } - @org.junit.Test + @Test public void fullNameSignatureTest() throws ReflectiveOperationException { - String signature = MethodWrapper.getMethodSignature(Test.class.getMethod("genericDummyMethod", Thread.class, Exception.class), true); + String signature = MethodWrapper.getMethodSignature(ReflectionTest.class.getMethod("genericDummyMethod", Thread.class, Exception.class), true); assertEquals("java.lang.reflect.Method genericDummyMethod(java.lang.Thread,java.lang.Exception)", signature); } - @org.junit.Test + @Test public void signatureObjectTest() throws ReflectiveOperationException { - MethodWrapper.MethodSignature signature = MethodWrapper.MethodSignature.of(Test.class.getMethod("genericDummyMethod", Thread.class, Exception.class), false); + MethodWrapper.MethodSignature signature = MethodWrapper.MethodSignature.of(ReflectionTest.class.getMethod("genericDummyMethod", Thread.class, Exception.class), false); assertEquals("Method", signature.getReturnType()); assertEquals("genericDummyMethod", signature.getName()); - assertArrayEquals(new String[] { + assertArrayEquals(new String[]{ "Thread", - "Exception" }, signature.getParameterTypes()); + "Exception"}, signature.getParameterTypes()); } - @org.junit.Test + @Test public void signatureFromStringTest() { MethodWrapper.MethodSignature signature = MethodWrapper.MethodSignature.fromString("java.lang.reflect.Method genericDummyMethod(java.lang.Thread,java.lang.Exception)"); assertEquals("java.lang.reflect.Method", signature.getReturnType()); @@ -78,13 +80,13 @@ public void signatureFromStringTest() { assertEquals("java.lang.Exception", signature.getParameterType(1)); } - @org.junit.Test + @Test public void wildcardTest() throws ReflectiveOperationException { MethodWrapper.MethodSignature wildcardSignature = MethodWrapper.MethodSignature.fromString("* wildcardMethod*(String)"); - MethodWrapper.MethodSignature testSignature1 = MethodWrapper.MethodSignature.of(Test.class.getMethod("wildcardMethod1", String.class), false); - MethodWrapper.MethodSignature testSignature2 = MethodWrapper.MethodSignature.of(Test.class.getMethod("wildcardMethod2", String.class), false); - MethodWrapper.MethodSignature testSignature3 = MethodWrapper.MethodSignature.of(Test.class.getMethod("wildcardMethod3", boolean.class), false); - MethodWrapper.MethodSignature testSignature4 = MethodWrapper.MethodSignature.of(Test.class.getMethod("wildCardMethod4", String.class), false); + MethodWrapper.MethodSignature testSignature1 = MethodWrapper.MethodSignature.of(ReflectionTest.class.getMethod("wildcardMethod1", String.class), false); + MethodWrapper.MethodSignature testSignature2 = MethodWrapper.MethodSignature.of(ReflectionTest.class.getMethod("wildcardMethod2", String.class), false); + MethodWrapper.MethodSignature testSignature3 = MethodWrapper.MethodSignature.of(ReflectionTest.class.getMethod("wildcardMethod3", boolean.class), false); + MethodWrapper.MethodSignature testSignature4 = MethodWrapper.MethodSignature.of(ReflectionTest.class.getMethod("wildCardMethod4", String.class), false); assertTrue(wildcardSignature.matches(testSignature1)); assertTrue(wildcardSignature.matches(testSignature2));