feat: 1.2.1

- gradle version upgrade
- Strings.equalsIgnoreCase
- interfaces

Author: javaquery

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.5-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.4.2-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

src/main/java/com/javaquery/util/iface/Processor.java

@@ -0,0 +1,15 @@
+package com.javaquery.util.iface;
+
+/**
+ * @author vicky.thakor
+ * @since 2022-05-16
+ */
+public interface Processor<T, R> {
+
+    /**
+     * Process T object and return the value.
+     * @param t - input object
+     * @return return value
+     */
+    R process(T t);
+}

src/main/java/com/javaquery/util/iface/Reader.java

@@ -0,0 +1,18 @@
+package com.javaquery.util.iface;
+
+import com.javaquery.util.io.JFile;
+
+import java.io.IOException;
+
+/**
+ * @author vicky.thakor
+ * @since 2022-05-16
+ */
+public interface Reader<T> {
+    /**
+     * @param file - file to read
+     * @return return the result
+     * @throws IOException exception
+     */
+    T read(JFile file) throws IOException;
+}

src/main/java/com/javaquery/util/iface/Writer.java

@@ -0,0 +1,18 @@
+package com.javaquery.util.iface;
+
+import com.javaquery.util.io.JFile;
+
+import java.io.IOException;
+
+/**
+ * @author vicky.thakor
+ * @since 2022-05-16
+ */
+public interface Writer<T> {
+    /**
+     * @param data - data to write
+     * @param file - file to write
+     * @throws IOException exception
+     */
+    void write(T data, JFile file) throws IOException;
+}

src/main/java/com/javaquery/util/string/Strings.java

@@ -212,6 +212,24 @@ public static void notEquals(String a, String b, ExecutableFunction executableFu
     }
   }
 
+  /**
+   * Compares this String to another String, ignoring case considerations. Two strings are considered equal ignoring case if they are of the same length and corresponding characters in the two strings are equal ignoring case.
+   * Two characters c1 and c2 are considered the same ignoring case if at least one of the following is true:
+   * <ul>
+   *     <li>The two characters are the same (as compared by the == operator)</li>
+   *     <li>Calling Character.toLowerCase(Character.toUpperCase(char)) on each character produces the same result</li>
+   * </ul>
+   *
+   * @param a String
+   * @param b String to be compared with {@code a} for equality (ignoring case considerations)
+   * @return {@code true} if the provided Strings are equalsIgnoreCase otherwise
+   *    *     {@code false}
+   */
+  public static boolean equalsIgnoreCase(String a, String b){
+    return (a == null && b == null)
+            || (a != null && a.equalsIgnoreCase(b));
+  }
+
   /**
    * Compares this String to another String, ignoring case considerations. Two strings are considered equal ignoring case if they are of the same length and corresponding characters in the two strings are equal ignoring case.
    * Two characters c1 and c2 are considered the same ignoring case if at least one of the following is true:
@@ -225,7 +243,7 @@ public static void notEquals(String a, String b, ExecutableFunction executableFu
    * @param executableFunction lambda function given executed if the provided Strings are equals (ignoring case considerations).
    */
   public static void equalsIgnoreCase(String a, String b, ExecutableFunction executableFunction){
-    if(a != null && a.equalsIgnoreCase(b)){
+    if(equalsIgnoreCase(a, b)){
       executableFunction.execute();
     }
   }
@@ -238,7 +256,7 @@ public static void equalsIgnoreCase(String a, String b, ExecutableFunction execu
    * @param executableFunction lambda function given executed if the provided Strings are non equals (ignoring case considerations).
    */
   public static void notEqualsIgnoreCase(String a, String b, ExecutableFunction executableFunction){
-    if(a != null && !a.equalsIgnoreCase(b)){
+    if(!equalsIgnoreCase(a, b)){
       executableFunction.execute();
     }
   }

src/test/java/com/javaquery/util/string/TestStrings.java

@@ -116,6 +116,15 @@ public void test_notEquals(){
 
   @Test
   public void test_equalsIgnoreCase(){
+    Assertions.assertTrue(Strings.equalsIgnoreCase("a", "A"));
+    Assertions.assertTrue(Strings.equalsIgnoreCase("a", "a"));
+    Assertions.assertTrue(Strings.equalsIgnoreCase(null, null));
+    Assertions.assertFalse(Strings.equalsIgnoreCase("a", null));
+    Assertions.assertFalse(Strings.equalsIgnoreCase(null, "b"));
+  }
+
+  @Test
+  public void test_equalsIgnoreCaseWithExecutableFunction(){
     Assertions.assertThrows(RuntimeException.class, () -> Strings.equalsIgnoreCase("A", "A", () -> {throw new RuntimeException("Function executed when two Strings are equalsIgnoreCase");}));
     Assertions.assertThrows(RuntimeException.class, () -> Strings.equalsIgnoreCase("A", "a", () -> {throw new RuntimeException("Function executed when two Strings are equalsIgnoreCase");}));
     Strings.equalsIgnoreCase("A", "b", () -> {throw new RuntimeException("Function won't execute when two Strings are not equalsIgnoreCase");});