#7 - Introduced string predicates

src/main/java/io/github/avegera/predicate4j/Predicates.java

@@ -13,6 +13,8 @@ private Predicates() {
         //private constructor
     }
 
+    //Object predicates
+
     public static <T> Predicate<T> isEqualTo(T object) {
         return it -> Objects.equals(it, object);
     }
@@ -45,6 +47,8 @@ public static <T> Predicate<T> alwaysFalse() {
         return it -> false;
     }
 
+    //Boolean predicates
+
     public static Predicate<Boolean> isTrue() {
         return bool -> bool != null && bool;
     }
@@ -61,6 +65,8 @@ public static Predicate<Boolean> notFalse() {
         return bool -> bool == null || bool;
     }
 
+    //Collection predicates
+
     public static <T extends Collection<?>> Predicate<T> isEmpty() {
         return collection -> collection == null || collection.isEmpty();
     }
@@ -77,11 +83,53 @@ public static <T extends Collection<?>> Predicate<T> notHaveSize(int size) {
         return collection -> (collection != null ? collection.size() : 0) != size;
     }
 
-    public static <T extends Collection<R>, R> Predicate<T> contains(R element) {
+    public static <T extends Collection<R>, R> Predicate<T> containsElement(R element) {
         return collection -> collection != null && collection.contains(element);
     }
 
-    public static <T extends Collection<R>, R> Predicate<T> notContain(R element) {
+    public static <T extends Collection<R>, R> Predicate<T> notContainsElement(R element) {
         return collection -> collection == null || !collection.contains(element);
     }
+
+    //String predicates
+
+    public static Predicate<String> isEmptyString() {
+        return str -> str == null || str.isEmpty();
+    }
+
+    public static Predicate<String> notEmptyString() {
+        return str -> str != null && !str.isEmpty();
+    }
+
+    public static Predicate<String> containsSubstring(String substring) {
+        return str -> str != null && str.contains(substring);
+    }
+
+    public static Predicate<String> notContainsSubstring(String substring) {
+        return str -> str == null || !str.contains(substring);
+    }
+
+    public static Predicate<String> startsWith(String prefix) {
+        return str -> str != null && prefix != null && str.startsWith(prefix);
+    }
+
+    public static Predicate<String> notStartsWith(String prefix) {
+        return str -> str == null || prefix == null || !str.startsWith(prefix);
+    }
+
+    public static Predicate<String> endsWith(String suffix) {
+        return str -> str != null && suffix != null && str.endsWith(suffix);
+    }
+
+    public static Predicate<String> notEndsWith(String suffix) {
+        return str -> str == null || suffix == null || !str.endsWith(suffix);
+    }
+
+    public static Predicate<String> matches(String regex) {
+        return str -> str != null && regex != null && str.matches(regex);
+    }
+
+    public static Predicate<String> notMatches(String regex) {
+        return str -> str == null || regex == null || !str.matches(regex);
+    }
 }

src/main/java/io/github/avegera/predicate4j/api/WhereList.java

@@ -14,5 +14,5 @@ public interface WhereList<T, R> extends WhereObject<T, List<R>> {
 
     RichPredicate<T> contains(R element);
 
-    RichPredicate<T> notContain(R element);
+    RichPredicate<T> notContains(R element);
 }

src/main/java/io/github/avegera/predicate4j/api/WhereString.java

@@ -0,0 +1,24 @@
+package io.github.avegera.predicate4j.api;
+
+public interface WhereString<T> extends WhereObject<T, String> {
+
+    RichPredicate<T> isEmpty();
+
+    RichPredicate<T> notEmpty();
+
+    RichPredicate<T> contains(String substring);
+
+    RichPredicate<T> notContains(String substring);
+
+    RichPredicate<T> startsWith(String prefix);
+
+    RichPredicate<T> notStartsWith(String prefix);
+
+    RichPredicate<T> endsWith(String suffix);
+
+    RichPredicate<T> notEndsWith(String suffix);
+
+    RichPredicate<T> matches(String regex);
+
+    RichPredicate<T> notMatches(String regex);
+}

src/main/java/io/github/avegera/predicate4j/api/WhereType.java

@@ -8,4 +8,6 @@ public interface WhereType {
     <T> WhereBoolean<T> booleanValue(Function<T, Boolean> mapper);
 
     <T, R> WhereList<T, R> list(Function<T, List<R>> mapper);
+
+    <T> WhereString<T> string(Function<T, String> mapper);
 }

src/main/java/io/github/avegera/predicate4j/impl/WhereListImpl.java

@@ -35,11 +35,11 @@ public RichPredicate<T> notHaveSize(int size) {
 
     @Override
     public RichPredicate<T> contains(R element) {
-        return getPredicate(Predicates.contains(element));
+        return getPredicate(Predicates.containsElement(element));
     }
 
     @Override
-    public RichPredicate<T> notContain(R element) {
-        return getPredicate(Predicates.notContain(element));
+    public RichPredicate<T> notContains(R element) {
+        return getPredicate(Predicates.notContainsElement(element));
     }
 }

src/main/java/io/github/avegera/predicate4j/impl/WhereStringImpl.java

@@ -0,0 +1,64 @@
+package io.github.avegera.predicate4j.impl;
+
+import io.github.avegera.predicate4j.Predicates;
+import io.github.avegera.predicate4j.api.RichPredicate;
+import io.github.avegera.predicate4j.api.WhereString;
+
+import java.util.function.Function;
+
+public class WhereStringImpl<T> extends WhereObjectImpl<T, String> implements WhereString<T> {
+
+    public WhereStringImpl(Function<T, String> mapper) {
+        super(mapper);
+    }
+
+    @Override
+    public RichPredicate<T> isEmpty() {
+        return getPredicate(Predicates.isEmptyString());
+    }
+
+    @Override
+    public RichPredicate<T> notEmpty() {
+        return getPredicate(Predicates.notEmptyString());
+    }
+
+    @Override
+    public RichPredicate<T> contains(String substring) {
+        return getPredicate(Predicates.containsSubstring(substring));
+    }
+
+    @Override
+    public RichPredicate<T> notContains(String substring) {
+        return getPredicate(Predicates.notContainsSubstring(substring));
+    }
+
+    @Override
+    public RichPredicate<T> startsWith(String prefix) {
+        return getPredicate(Predicates.startsWith(prefix));
+    }
+
+    @Override
+    public RichPredicate<T> notStartsWith(String prefix) {
+        return getPredicate(Predicates.notStartsWith(prefix));
+    }
+
+    @Override
+    public RichPredicate<T> endsWith(String suffix) {
+        return getPredicate(Predicates.endsWith(suffix));
+    }
+
+    @Override
+    public RichPredicate<T> notEndsWith(String suffix) {
+        return getPredicate(Predicates.notEndsWith(suffix));
+    }
+
+    @Override
+    public RichPredicate<T> matches(String regex) {
+        return getPredicate(Predicates.matches(regex));
+    }
+
+    @Override
+    public RichPredicate<T> notMatches(String regex) {
+        return getPredicate(Predicates.notMatches(regex));
+    }
+}

src/main/java/io/github/avegera/predicate4j/impl/WhereTypeImpl.java

@@ -2,6 +2,7 @@
 
 import io.github.avegera.predicate4j.api.WhereBoolean;
 import io.github.avegera.predicate4j.api.WhereList;
+import io.github.avegera.predicate4j.api.WhereString;
 import io.github.avegera.predicate4j.api.WhereType;
 
 import java.util.List;
@@ -18,4 +19,9 @@ public <T> WhereBoolean<T> booleanValue(Function<T, Boolean> mapper) {
     public <T, R> WhereList<T, R> list(Function<T, List<R>> mapper) {
         return new WhereListImpl<>(mapper);
     }
+
+    @Override
+    public <T> WhereString<T> string(Function<T, String> mapper) {
+        return new WhereStringImpl<>(mapper);
+    }
 }