Merge pull request #6 from CrissNamon/dev

1.1

Author: CrissNamon

.github/workflows/maven.yml

@@ -20,12 +20,12 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v3
-    - name: Set up JDK 8
-      uses: actions/setup-java@v3
-      with:
-        java-version: '8'
-        distribution: 'temurin'
-        cache: maven
-    - name: Build with Maven
-      run: mvn -B test --file pom.xml
+      - uses: actions/checkout@v3
+      - name: Set up JDK 8
+        uses: actions/setup-java@v3
+        with:
+          java-version: '8'
+          distribution: 'temurin'
+          cache: maven
+      - name: Build with Maven
+        run: mvn -B test --file pom.xml

README.md

@@ -3,6 +3,7 @@
 [![Build](https://github.com/CrissNamon/aide/actions/workflows/maven.yml/badge.svg)](https://github.com/CrissNamon/aide/actions/workflows/maven.yml)
 
 Aide is a set of useful utils to simplify your code
+
 ## Content
 
 * Reflection
@@ -13,6 +14,7 @@ Aide is a set of useful utils to simplify your code
 ## Use
 
 Artifact ids:
+
 - all -> aide-all
 - reflection -> aide-reflection
 - optional -> aide-optional
@@ -23,14 +25,14 @@ Artifact ids:
 <dependency>
   <groupId>tech.hiddenproject</groupId>
   <artifactId>aide-all</artifactId>
-  <version>1.0</version>
+  <version>1.1</version>
 </dependency>
 ```
 
 ### Gradle
 
 ```groovy
-implementation 'tech:hiddenproject:aide-all:1.0'
+implementation 'tech:hiddenproject:aide-all:1.1'
 ```
 
 ## Resources
@@ -39,13 +41,14 @@ ___
 
 * Learn more at Aide [Wiki](https://github.com/CrissNamon/aide/wiki)
 * Look at some examples
-  in [example](https://github.com/CrissNamon/aide/tree/main/aide-all/src/main/java/tech/hiddenproject/aide/example) package
+  in [example](https://github.com/CrissNamon/aide/tree/main/aide-all/src/main/java/tech/hiddenproject/aide/example)
+  package
 
 ## Dependencies and source
 
 ___
 
-Aide has no dependencies and use only Java 8.</p> 
+Aide has no dependencies and use only Java 8.</p>
 
 ## Repository info
 

aide-all/pom.xml

@@ -7,12 +7,12 @@
     <dependency>
       <artifactId>aide-optional</artifactId>
       <groupId>tech.hiddenproject</groupId>
-      <version>1.0</version>
+      <version>1.1</version>
     </dependency>
     <dependency>
       <artifactId>aide-reflection</artifactId>
       <groupId>tech.hiddenproject</groupId>
-      <version>1.0</version>
+      <version>1.1</version>
     </dependency>
   </dependencies>
 
@@ -21,7 +21,7 @@
   <parent>
     <artifactId>aide</artifactId>
     <groupId>tech.hiddenproject</groupId>
-    <version>1.0</version>
+    <version>1.1</version>
   </parent>
 
   <properties>

aide-all/src/main/java/tech/hiddenproject/aide/example/ReflectionExample.java

@@ -1,8 +1,19 @@
 package tech.hiddenproject.aide.example;
 
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.stream.Collectors;
 import tech.hiddenproject.aide.reflection.LambdaWrapper;
 import tech.hiddenproject.aide.reflection.LambdaWrapperHolder;
+import tech.hiddenproject.aide.reflection.MethodHolder;
+import tech.hiddenproject.aide.reflection.WrapperHolder;
 import tech.hiddenproject.aide.reflection.annotation.ExactInvoker;
+import tech.hiddenproject.aide.reflection.matcher.ArgumentMatcherHolder;
+import tech.hiddenproject.aide.reflection.signature.LambdaMetadata;
+import tech.hiddenproject.aide.reflection.signature.MatcherSignature;
+import tech.hiddenproject.aide.reflection.signature.MethodSignature;
+import tech.hiddenproject.aide.reflection.util.ReflectionUtil;
 
 /**
  * @author Danila Rassokhin
@@ -11,38 +22,122 @@ public class ReflectionExample {
 
 
   public ReflectionExample() {
-    LambdaWrapperHolder lambdaWrapperHolder = LambdaWrapperHolder.INSTANCE;
+    // Create holder with default LambdaWrapper initialization
+    LambdaWrapperHolder lambdaWrapperHolder = LambdaWrapperHolder.DEFAULT;
+    // Load all annotated methods from TestInterface
     lambdaWrapperHolder.add(TestInterface.class);
-
+    // Create caller
     TestClass caller = new TestClass();
 
-    LambdaWrapper getter = lambdaWrapperHolder.wrap(caller, "get");
-
+    // Find getter
+    Method getMethod = ReflectionUtil.getMethod(TestClass.class, "get");
+    // Wrap getter
+    WrapperHolder<LambdaWrapper> getterHolder = lambdaWrapperHolder.wrap(getMethod);
+    LambdaWrapper getter = getterHolder.getWrapper();
+    // Invoke getter
     Long id = getter.get(caller);
     System.out.println("Getter result: " + id);
 
-    LambdaWrapper setter = lambdaWrapperHolder.wrap(caller, "set", String.class);
-
+    // Get setter
+    Method setMethod = ReflectionUtil.getMethod(TestClass.class, "set", String.class);
+    // Wrap setter
+    WrapperHolder<LambdaWrapper> setterHolder = lambdaWrapperHolder.wrap(setMethod);
+    LambdaWrapper setter = setterHolder.getWrapper();
+    // Invoke setter
     setter.set(caller, "Hello");
 
-    LambdaWrapper function = lambdaWrapperHolder.wrap(caller, "apply", String.class);
-
+    // Find apply method
+    Method functionMethod = ReflectionUtil.getMethod(TestClass.class, "apply", String.class);
+    // Wrap apply method
+    WrapperHolder<LambdaWrapper> functionHolder = lambdaWrapperHolder.wrap(functionMethod);
+    LambdaWrapper function = functionHolder.getWrapper();
+    // Invoke apply method and get result
     int res = function.apply(caller, "Hi");
     System.out.println("Function result: " + res);
 
-    TestInterface testInterface = lambdaWrapperHolder.wrapExact(caller, "special", int.class);
-    String special = testInterface.special(caller, 1);
+    // Find special method
+    Method specialMethod = ReflectionUtil.getMethod(TestClass.class, "exact", int.class);
+    // Wrap special method with exact same wrapper from TestInterface
+    WrapperHolder<TestInterface> specialHolder = lambdaWrapperHolder.wrapExact(
+        specialMethod, TestInterface.class);
+    TestInterface testInterface = specialHolder.getWrapper();
+    // Invoke special method and get result
+    String special = testInterface.exact(caller, 1);
     System.out.println("Special result: " + special);
+
+    // Get method with var args
+    Method varArgsMethod = ReflectionUtil.getMethod(TestClass.class, "varargs", Object[].class);
+    // Wrap method with var args
+    WrapperHolder<LambdaWrapper> varArgsHolder = lambdaWrapperHolder.wrap(varArgsMethod);
+    LambdaWrapper varargs = varArgsHolder.getWrapper();
+    // Invoke method and get result
+    Class<?>[] varArgsTypes = varargs.apply(caller, new Object[]{"Hello", 1});
+    System.out.println("Var args result: " + Arrays.toString(varArgsTypes));
+
+    // Find constructor of TestClass
+    Constructor<TestClass> constructorMethod = ReflectionUtil.getConstructor(TestClass.class);
+    // Wrap constructor
+    MethodHolder<LambdaWrapper, ReflectionExample, TestClass> constructor =
+        lambdaWrapperHolder.wrapSafe(constructorMethod);
+    // Call constructor
+    caller = constructor.invokeStatic();
+
+    // Wrap special method
+    MethodHolder<LambdaWrapper, TestClass, String> methodHolder = lambdaWrapperHolder.wrapSafe(
+        specialMethod);
+    // Invoke special method
+    String r = methodHolder.invoke(caller, 1);
+
+    // Wrap setter
+    MethodHolder<LambdaWrapper, TestClass, Void> setHolder = lambdaWrapperHolder.wrapSafe(
+        setMethod);
+    // Invoke setter
+    setHolder.invoke(caller, "hello");
+
+    // Find static method
+    Method staticMethod = ReflectionUtil.getMethod(TestClass.class, "staticMethod", String.class);
+    // Wrap static method
+    MethodHolder<LambdaWrapper, TestClass, Integer> staticHolder = lambdaWrapperHolder.wrapSafe(
+        staticMethod);
+    // Invoke static method without caller
+    int staticResult = staticHolder.invokeStatic("Hello");
+    System.out.println("Static result: " + staticResult);
+
+    // Create metadata for wrapper lambda
+    Method testMethod = ReflectionUtil.getMethod(
+        TestInterface.class, "exact", Object.class, int.class);
+    LambdaMetadata testWrapper = LambdaMetadata.from(testMethod);
+    // Wrap special method with your own lambda metadata
+    MethodHolder<TestInterface, TestClass, String> testHolder = lambdaWrapperHolder.wrapSafe(
+        specialMethod, testWrapper);
+    // Create new ArgumentMatcher for wrapper
+    MethodSignature methodSignature = MethodSignature.fromWrapper(testMethod);
+    MatcherSignature<TestInterface> matcherSignature = new MatcherSignature<>(
+        TestInterface.class, methodSignature);
+    ArgumentMatcherHolder.INSTANCE.addMatcher(
+        matcherSignature, (holder, original, args) -> holder.getWrapper()
+            .exact(args[0], (int) args[1]));
+    // Invoke special method with custom argument matcher
+    testHolder.invoke(caller, 1);
   }
 
   public interface TestInterface {
 
     @ExactInvoker
-    String special(Object caller, int id);
+    String exact(Object caller, int id);
   }
 
   public static class TestClass {
 
+    public TestClass() {
+      System.out.println("Test class constructor invoked!");
+    }
+
+    public static int staticMethod(String s) {
+      System.out.println("Static invoked");
+      return s.length();
+    }
+
     public Long get() {
       System.out.println("Getter invoked");
       return 1L;
@@ -57,9 +152,14 @@ public int apply(String arg) {
       return arg.length();
     }
 
-    public String special(int id) {
+    public String exact(int id) {
       System.out.println("Special invoked: " + id);
       return String.valueOf(id);
     }
+
+    public Class<?>[] varargs(Object... args) {
+      return Arrays.stream(args).map(Object::getClass).collect(Collectors.toList())
+          .toArray(new Class[]{});
+    }
   }
 }

aide-optional/pom.xml

@@ -8,15 +8,15 @@
   <parent>
     <artifactId>aide</artifactId>
     <groupId>tech.hiddenproject</groupId>
-    <version>1.0</version>
+    <version>1.1</version>
   </parent>
 
-  <version>1.0</version>
-
   <properties>
     <maven.compiler.source>8</maven.compiler.source>
     <maven.compiler.target>8</maven.compiler.target>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
   </properties>
 
+  <version>1.1</version>
+
 </project>

aide-optional/src/main/java/tech/hiddenproject/aide/optional/Action.java

@@ -1,6 +1,8 @@
 package tech.hiddenproject.aide.optional;
 
 /**
+ * No args version of {@link java.util.function.Consumer}.
+ *
  * @author Danila Rassokhin
  */
 public interface Action {

aide-optional/src/main/java/tech/hiddenproject/aide/optional/BooleanOptional.java

@@ -70,7 +70,7 @@ public void ifFalseThen(Action action) {
    * If value is true then throws exception.
    *
    * @param throwableSupplier {@link Supplier} for {@link Throwable}
-   * @param <X> {@link Throwable} type
+   * @param <X>               {@link Throwable} type
    * @throws X if value is true
    */
   public <X extends Throwable> void ifTrueThrow(Supplier<X> throwableSupplier) throws X {
@@ -83,7 +83,7 @@ public <X extends Throwable> void ifTrueThrow(Supplier<X> throwableSupplier) thr
    * If value is false then throws exception.
    *
    * @param throwableSupplier {@link Supplier} for {@link Throwable}
-   * @param <X> {@link Throwable} type
+   * @param <X>               {@link Throwable} type
    * @throws X if false is true
    */
   public <X extends Throwable> void ifFalseThrow(Supplier<X> throwableSupplier) throws X {

aide-optional/src/main/java/tech/hiddenproject/aide/optional/IfTrueConditional.java

@@ -2,6 +2,7 @@
 
 import java.util.LinkedHashMap;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Optional;
 import java.util.function.Predicate;
 import java.util.function.Supplier;
@@ -66,7 +67,7 @@ public ConditionalThen<T> ifTrue(boolean condition) {
    * @return Result of conditional
    */
   public <D> D orElse(D defaultValue) {
-    return get().map(value -> (D) value).orElse(defaultValue);
+    return get().map(value -> (D) value.getValue().get()).orElse(defaultValue);
   }
 
   /**
@@ -77,7 +78,7 @@ public <D> D orElse(D defaultValue) {
    * @return Result of conditional
    */
   public <D> D orElseGet(Supplier<D> defaultValue) {
-    return get().map(value -> (D) value).orElseGet(defaultValue);
+    return get().map(value -> (D) value.getValue().get()).orElseGet(defaultValue);
   }
 
   /**
@@ -90,15 +91,15 @@ public <D> D orElseGet(Supplier<D> defaultValue) {
    * @throws X if all branches failed
    */
   public <X extends Throwable, D> D orElseThrows(Supplier<? extends X> exceptionSupplier) throws X {
-    return get().map(value -> (D) value).orElseThrow(exceptionSupplier);
+    return get().map(value -> (D) value.getValue().get()).orElseThrow(exceptionSupplier);
   }
 
   /**
    * @return Result of conditional as {@link Optional}
    */
-  private Optional<T> get() {
-    return conditions.entrySet().stream().filter(entry -> entry.getKey().test())
-        .map(entry -> entry.getValue().get())
+  private Optional<Entry<BooleanAction, Supplier<T>>> get() {
+    return conditions.entrySet().stream()
+        .filter(entry -> entry.getKey().test())
         .findFirst();
   }
 

aide-optional/src/main/java/tech/hiddenproject/aide/optional/ObjectUtils.java

@@ -14,7 +14,7 @@ public class ObjectUtils {
    * Checks if null objects count is greater than maxCount.
    *
    * @param maxCount Max count of null objects
-   * @param objects Objects to check
+   * @param objects  Objects to check
    * @return true if null objects count is greater than maxCount
    */
   public static boolean isMoreThanNull(int maxCount, Object... objects) {
@@ -33,4 +33,25 @@ public static boolean isMoreThanNull(Object... objects) {
     return isMoreThanNull(1, objects);
   }
 
+  /**
+   * Checks if object classes equals.
+   *
+   * @param o1 {@link Object}
+   * @param o2 {@link Object}
+   * @return true if o1.getClass.equals(o2.getClass())
+   */
+  public static boolean equalsClass(Object o1, Object o2) {
+    return o1.getClass().equals(o2.getClass());
+  }
+
+  /**
+   * Checks if object is instance of class.
+   *
+   * @param o {@link Object}
+   * @param c {@link Class}
+   * @return true if o.getClass().equals(c)
+   */
+  public static boolean isInstanceOf(Object o, Class<?> c) {
+    return o.getClass().equals(c);
+  }
 }