Skip to content

Commit

Permalink
more convergence and reduce operators
Browse files Browse the repository at this point in the history
  • Loading branch information
@njr-11
njr-11 committed Nov 6, 2024
1 parent 52d42e9 commit 59e75cc
Show file tree
Hide file tree
Showing 5 changed files with 113 additions and 82 deletions.
25 changes: 13 additions & 12 deletions api/src/main/java/jakarta/data/metamodel/Attribute.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -22,6 +22,7 @@
import java.util.Set;

import jakarta.data.Sort;
import jakarta.data.metamodel.Restrict.BasicRestriction;
import jakarta.data.metamodel.Restriction.Operator;

/**
Expand All @@ -31,16 +32,16 @@
*/
public interface Attribute<T> {

default <V> Restriction.Single<T, V> equal(V value) {
return new Restriction.Single<>(name(), Operator.EQUAL, value);
default <V> BasicRestriction<T, V> equal(V value) {
return new BasicRestriction<>(name(), Operator.EQUAL, value);
}

default <V> Restriction.Single<T, Set<V>> in(@SuppressWarnings("unchecked") V... values) {
return new Restriction.Single<>(name(), Operator.IN, Set.of(values));
default <V> BasicRestriction<T, Set<V>> in(@SuppressWarnings("unchecked") V... values) {
return new BasicRestriction<>(name(), Operator.IN, Set.of(values));
}

default Restriction.Single<T, Object> isNull() {
return new Restriction.Single<>(name(), Operator.EQUAL, null);
default BasicRestriction<T, Object> isNull() {
return new BasicRestriction<>(name(), Operator.EQUAL, null);
}

/**
Expand All @@ -51,15 +52,15 @@ default Restriction.Single<T, Object> isNull() {
*/
String name();

default <V> Restriction.Single<T, V> not(V value) {
return new Restriction.Single<>(name(), NOT, Operator.EQUAL, value);
default <V> BasicRestriction<T, V> not(V value) {
return new BasicRestriction<>(name(), NOT, Operator.EQUAL, value);
}

default <V> Restriction.Single<T, Set<V>> notIn(@SuppressWarnings("unchecked") V... values) {
return new Restriction.Single<>(name(), NOT, Operator.IN, Set.of(values));
default <V> BasicRestriction<T, Set<V>> notIn(@SuppressWarnings("unchecked") V... values) {
return new BasicRestriction<>(name(), NOT, Operator.IN, Set.of(values));
}

default Restriction.Single<T, Object> notNull() {
return new Restriction.Single<>(name(), NOT, Operator.EQUAL, null);
default BasicRestriction<T, Object> notNull() {
return new BasicRestriction<>(name(), NOT, Operator.EQUAL, null);
}
}
39 changes: 37 additions & 2 deletions api/src/main/java/jakarta/data/metamodel/Restrict.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -29,14 +29,49 @@ public enum Restrict {

@SafeVarargs
static <T> Restriction<T> all(Restriction<T>... restrictions) {
return new Restriction.Multiple<>(All, List.of(restrictions));
return new CompositeRestriction<>(All, List.of(restrictions));
}

@SafeVarargs
static <T> Restriction<T> any(Restriction<T>... restrictions) {
return new Restriction.Multiple<>(Any, List.of(restrictions));
return new CompositeRestriction<>(Any, List.of(restrictions));
}

// TODO Need to think more about how to best cover negation of multiple
// and then make negation of Single consistent with it

// The following are internal implementation classes.
// The proper way for users to obtain instances is via the static metamodel.

record BasicRestriction<T, V>(
String field,
boolean negated,
Operator comparison,
boolean ignoreCase,
V value) implements Restriction.Basic<T, V> {

BasicRestriction(String field, boolean negated, Operator comparison, V value) {
this(field, negated, comparison, false, value);
}

BasicRestriction(String field, Operator comparison, V value) {
this(field, false, comparison, false, value);
}

BasicRestriction(String field, Operator comparison, boolean ignoreCase, V value) {
this(field, false, comparison, ignoreCase, value);
}
}

record CompositeRestriction<T>(
Restrict type,
List<Restriction<T>> restrictions,
boolean negated) implements Restriction.Composite<T> {

CompositeRestriction(
Restrict type,
List<Restriction<T>> restrictions) {
this(type, restrictions, false);
}
}
}
41 changes: 17 additions & 24 deletions api/src/main/java/jakarta/data/metamodel/Restriction.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,40 +20,33 @@
import java.util.List;

public interface Restriction<T> {
record Multiple<T>(
Restrict type,
List<Restriction<T>> list) implements Restriction<T> {
interface Basic<T, V> extends Restriction<T> {
Operator comparison();

String field();

boolean ignoreCase();

boolean negated();

V value();
}

record Single<T, V>(
String name,
boolean negated,
Operator comparison,
boolean ignoreCase,
V value) implements Restriction<T> {
Single(String name, boolean negated, Operator comparison, V value) {
this(name, negated, comparison, false, value);
}

Single(String name, Operator comparison, V value) {
this(name, false, comparison, false, value);
}

Single(String name, Operator comparison, boolean ignoreCase, V value) {
this(name, false, comparison, ignoreCase, value);
}
interface Composite<T> extends Restriction<T> {
List<Restriction<T>> restrictions();

Restrict type();

boolean negated();
}

enum Operator {
CONTAINS,
ENDS_WITH,
EQUAL,
GREATER_THAN,
GREATER_THAN_EQUAL,
IN,
LESS_THAN,
LESS_THAN_EQUAL,
LIKE,
STARTS_WITH
LIKE
}
}
17 changes: 9 additions & 8 deletions api/src/main/java/jakarta/data/metamodel/SortableAttribute.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -18,6 +18,7 @@
package jakarta.data.metamodel;

import jakarta.data.Sort;
import jakarta.data.metamodel.Restrict.BasicRestriction;
import jakarta.data.metamodel.Restriction.Operator;

/**
Expand Down Expand Up @@ -50,19 +51,19 @@ public interface SortableAttribute<T> extends Attribute<T> {
*/
Sort<T> desc();

default <V> Restriction.Single<T, V> greaterThan(V value) {
return new Restriction.Single<>(name(), Operator.GREATER_THAN, value);
default <V> BasicRestriction<T, V> greaterThan(V value) {
return new BasicRestriction<>(name(), Operator.GREATER_THAN, value);
}

default <V> Restriction.Single<T, V> greaterThanEqual(V value) {
return new Restriction.Single<>(name(), Operator.GREATER_THAN_EQUAL, value);
default <V> BasicRestriction<T, V> greaterThanEqual(V value) {
return new BasicRestriction<>(name(), Operator.GREATER_THAN_EQUAL, value);
}

default <V> Restriction.Single<T, V> lessThan(V value) {
return new Restriction.Single<>(name(), Operator.LESS_THAN, value);
default <V> BasicRestriction<T, V> lessThan(V value) {
return new BasicRestriction<>(name(), Operator.LESS_THAN, value);
}

default <V> Restriction.Single<T, V> lessThanEqual(V value) {
return new Restriction.Single<>(name(), Operator.LESS_THAN_EQUAL, value);
default <V> BasicRestriction<T, V> lessThanEqual(V value) {
return new BasicRestriction<>(name(), Operator.LESS_THAN_EQUAL, value);
}
}
73 changes: 37 additions & 36 deletions api/src/main/java/jakarta/data/metamodel/TextAttribute.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -21,6 +21,7 @@
import static jakarta.data.metamodel.Restrict.NOT;

import jakarta.data.Sort;
import jakarta.data.metamodel.Restrict.BasicRestriction;
import jakarta.data.metamodel.Restriction.Operator;

/**
Expand All @@ -37,12 +38,12 @@ public interface TextAttribute<T> extends SortableAttribute<T> {
*/
Sort<T> ascIgnoreCase();

default Restriction.Single<T, String> contains(String pattern) {
return new Restriction.Single<>(name(), Operator.CONTAINS, pattern);
default BasicRestriction<T, String> contains(String pattern) {
return new BasicRestriction<>(name(), Operator.LIKE, '%' + pattern + '%');
}

default Restriction.Single<T, String> containsIgnoreCase(String pattern) {
return new Restriction.Single<>(name(), Operator.CONTAINS, IGNORE_CASE, pattern);
default BasicRestriction<T, String> containsIgnoreCase(String pattern) {
return new BasicRestriction<>(name(), Operator.LIKE, IGNORE_CASE, '%' + pattern + '%');
}

/**
Expand All @@ -52,68 +53,68 @@ default Restriction.Single<T, String> containsIgnoreCase(String pattern) {
*/
Sort<T> descIgnoreCase();

default Restriction.Single<T, String> endsWith(String pattern) {
return new Restriction.Single<>(name(), Operator.ENDS_WITH, pattern);
default BasicRestriction<T, String> endsWith(String pattern) {
return new BasicRestriction<>(name(), Operator.LIKE, '%' + pattern);
}

default Restriction.Single<T, String> endsWithIgnoreCase(String pattern) {
return new Restriction.Single<>(name(), Operator.ENDS_WITH, IGNORE_CASE, pattern);
default BasicRestriction<T, String> endsWithIgnoreCase(String pattern) {
return new BasicRestriction<>(name(), Operator.LIKE, IGNORE_CASE, '%' + pattern);
}

default Restriction.Single<T, String> equalIgnoreCase(String value) {
return new Restriction.Single<>(name(), Operator.EQUAL, IGNORE_CASE, value);
default BasicRestriction<T, String> equalIgnoreCase(String value) {
return new BasicRestriction<>(name(), Operator.EQUAL, IGNORE_CASE, value);
}

default Restriction.Single<T, String> like(String pattern) {
return new Restriction.Single<>(name(), Operator.LIKE, pattern);
default BasicRestriction<T, String> like(String pattern) {
return new BasicRestriction<>(name(), Operator.LIKE, pattern);
}

default Restriction.Single<T, String> likeIgnoreCase(String pattern) {
return new Restriction.Single<>(name(), Operator.LIKE, IGNORE_CASE, pattern);
default BasicRestriction<T, String> likeIgnoreCase(String pattern) {
return new BasicRestriction<>(name(), Operator.LIKE, IGNORE_CASE, pattern);
}

default Restriction.Single<T, String> notContains(String pattern) {
return new Restriction.Single<>(name(), NOT, Operator.CONTAINS, pattern);
default BasicRestriction<T, String> notContains(String pattern) {
return new BasicRestriction<>(name(), NOT, Operator.LIKE, '%' + pattern + '%');
}

default Restriction.Single<T, String> notContainsIgnoreCase(String pattern) {
return new Restriction.Single<>(name(), NOT, Operator.CONTAINS, IGNORE_CASE, pattern);
default BasicRestriction<T, String> notContainsIgnoreCase(String pattern) {
return new BasicRestriction<>(name(), NOT, Operator.LIKE, IGNORE_CASE, '%' + pattern + '%');
}

default Restriction.Single<T, String> notEndsWith(String pattern) {
return new Restriction.Single<>(name(), NOT, Operator.ENDS_WITH, pattern);
default BasicRestriction<T, String> notEndsWith(String pattern) {
return new BasicRestriction<>(name(), NOT, Operator.LIKE, '%' + pattern);
}

default Restriction.Single<T, String> notEndsWithIgnoreCase(String pattern) {
return new Restriction.Single<>(name(), NOT, Operator.ENDS_WITH, IGNORE_CASE, pattern);
default BasicRestriction<T, String> notEndsWithIgnoreCase(String pattern) {
return new BasicRestriction<>(name(), NOT, Operator.LIKE, IGNORE_CASE, '%' + pattern);
}

default Restriction.Single<T, String> notIgnoreCase(String value) {
return new Restriction.Single<>(name(), NOT, Operator.EQUAL, IGNORE_CASE, value);
default BasicRestriction<T, String> notIgnoreCase(String value) {
return new BasicRestriction<>(name(), NOT, Operator.EQUAL, IGNORE_CASE, value);
}

default Restriction.Single<T, String> notLike(String pattern) {
return new Restriction.Single<>(name(), NOT, Operator.LIKE, pattern);
default BasicRestriction<T, String> notLike(String pattern) {
return new BasicRestriction<>(name(), NOT, Operator.LIKE, pattern);
}

default Restriction.Single<T, String> notLikeIgnoreCase(String pattern) {
return new Restriction.Single<>(name(), NOT, Operator.LIKE, IGNORE_CASE, pattern);
default BasicRestriction<T, String> notLikeIgnoreCase(String pattern) {
return new BasicRestriction<>(name(), NOT, Operator.LIKE, IGNORE_CASE, pattern);
}

default Restriction.Single<T, String> notStartsWith(String pattern) {
return new Restriction.Single<>(name(), NOT, Operator.STARTS_WITH, pattern);
default BasicRestriction<T, String> notStartsWith(String pattern) {
return new BasicRestriction<>(name(), NOT, Operator.LIKE, pattern + '%');
}

default Restriction.Single<T, String> notStartsWithIgnoreCase(String pattern) {
return new Restriction.Single<>(name(), NOT, Operator.STARTS_WITH, IGNORE_CASE, pattern);
default BasicRestriction<T, String> notStartsWithIgnoreCase(String pattern) {
return new BasicRestriction<>(name(), NOT, Operator.LIKE, IGNORE_CASE, pattern + '%');
}

default Restriction.Single<T, String> startsWith(String pattern) {
return new Restriction.Single<>(name(), Operator.STARTS_WITH, pattern);
default BasicRestriction<T, String> startsWith(String pattern) {
return new BasicRestriction<>(name(), Operator.LIKE, pattern + '%');
}

default Restriction.Single<T, String> startsWithIgnoreCase(String pattern) {
return new Restriction.Single<>(name(), Operator.STARTS_WITH, IGNORE_CASE, pattern);
default BasicRestriction<T, String> startsWithIgnoreCase(String pattern) {
return new BasicRestriction<>(name(), Operator.LIKE, IGNORE_CASE, pattern + '%');
}

}

0 comments on commit 59e75cc

Please sign in to comment.