runtime-field: Remove isNegated from all predicates

runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/StringField.java

@@ -37,7 +37,6 @@
  * @see  ComparableField
  * @see  HasStringOperators
  */
-
 public interface StringField<ENTITY, D> extends
     ComparableField<ENTITY, D, String>, 
     HasStringOperators<ENTITY, D> {

runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/StringForeignKeyField.java

@@ -40,7 +40,6 @@
  * @see  StringField
  * @see  HasFinder
  */
-
 public interface StringForeignKeyField<ENTITY, D, FK_ENTITY> 
 extends StringField<ENTITY, D>,
         HasNullableFinder<ENTITY, FK_ENTITY> {

runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/StringFieldImpl.java

@@ -174,7 +174,7 @@ public Predicate<ENTITY> notIn(Collection<String> values) {
 
     @Override
     public Predicate<ENTITY> equalIgnoreCase(String value) {
-        return new StringEqualIgnoreCasePredicate<>(this, value);
+        return new StringEqualIgnoreCasePredicate<>(this, value.toLowerCase());
     }
 
     @Override
@@ -199,16 +199,16 @@ public Predicate<ENTITY> isEmpty() {
 
     @Override
     public Predicate<ENTITY> startsWithIgnoreCase(String value) {
-        return new StringStartsWithIgnoreCasePredicate<>(this, value);
+        return new StringStartsWithIgnoreCasePredicate<>(this, value.toLowerCase());
     }
 
     @Override
     public Predicate<ENTITY> endsWithIgnoreCase(String value) {
-        return new StringEndsWithIgnoreCasePredicate<>(this, value);
+        return new StringEndsWithIgnoreCasePredicate<>(this, value.toLowerCase());
     }
 
     @Override
     public Predicate<ENTITY> containsIgnoreCase(String value) {
-        return new StringContainsIgnoreCasePredicate<>(this, value);
+        return new StringContainsIgnoreCasePredicate<>(this, value.toLowerCase());
     }
 }

runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/StringForeignKeyFieldImpl.java

@@ -217,7 +217,7 @@ public Predicate<ENTITY> notIn(Collection<String> values) {
 
     @Override
     public Predicate<ENTITY> equalIgnoreCase(String value) {
-        return new StringEqualIgnoreCasePredicate<>(this, value);
+        return new StringEqualIgnoreCasePredicate<>(this, value.toLowerCase());
     }
 
     @Override
@@ -242,16 +242,16 @@ public Predicate<ENTITY> isEmpty() {
 
     @Override
     public Predicate<ENTITY> startsWithIgnoreCase(String value) {
-        return new StringStartsWithIgnoreCasePredicate<>(this, value);
+        return new StringStartsWithIgnoreCasePredicate<>(this, value.toLowerCase());
     }
 
     @Override
     public Predicate<ENTITY> endsWithIgnoreCase(String value) {
-        return new StringEndsWithIgnoreCasePredicate<>(this, value);
+        return new StringEndsWithIgnoreCasePredicate<>(this, value.toLowerCase());
     }
 
     @Override
     public Predicate<ENTITY> containsIgnoreCase(String value) {
-        return new StringContainsIgnoreCasePredicate<>(this, value);
+        return new StringContainsIgnoreCasePredicate<>(this, value.toLowerCase());
     }
 }

runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/predicate/AbstractFieldPredicate.java

@@ -22,41 +22,45 @@
 import com.speedment.runtime.field.internal.util.Cast;
 import com.speedment.runtime.field.predicate.FieldPredicate;
 import com.speedment.runtime.field.predicate.PredicateType;
-import static java.util.Objects.requireNonNull;
+
 import java.util.function.Predicate;
 
+import static java.util.Objects.requireNonNull;
+
 /**
  * A predicate that contains meta-data about the {@link Field} that was used to
  * construct it.
  *
  * @param <ENTITY> the entity type that is being tested
- * @param <V> the wrapper type
- * @param <FIELD> the field in the entity that is operated on
+ * @param <FIELD>  the field in the entity that is operated on
  *
  * @author Emil Forslund
  * @since 3.0.0
  */
-public abstract class AbstractFieldPredicate<ENTITY, V, FIELD extends Field<ENTITY>>
-    extends AbstractPredicate<ENTITY> implements FieldPredicate<ENTITY> {
+public abstract class AbstractFieldPredicate<ENTITY, FIELD extends Field<ENTITY>>
+extends AbstractPredicate<ENTITY>
+implements FieldPredicate<ENTITY> {
 
     private final PredicateType predicateType;
     private final FIELD field;
     private final Predicate<ENTITY> tester;
 
     protected AbstractFieldPredicate(
-        final PredicateType predicateType,
-        final FIELD field,
-        final Predicate<ENTITY> tester,
-        final boolean negated
-    ) {
-        super(negated);
+            final PredicateType predicateType,
+            final FIELD field,
+            final Predicate<ENTITY> tester) {
+
         this.predicateType = requireNonNull(predicateType);
-        this.field = requireNonNull(field);
-        this.tester = requireNonNull(tester);
+        this.field         = requireNonNull(field);
+        this.tester        = requireNonNull(tester);
+    }
+
+    protected final Predicate<ENTITY> getTester() {
+        return tester;
     }
 
     @Override
-    protected boolean testWithoutNegation(ENTITY instance) {
+    public boolean test(ENTITY instance) {
         return tester.test(instance);
     }
 
@@ -65,11 +69,6 @@ public final PredicateType getPredicateType() {
         return predicateType;
     }
 
-    @Override
-    public final PredicateType getEffectivePredicateType() {
-        return isNegated() ? predicateType.negate() : predicateType;
-    }
-
     @Override
     public final FIELD getField() {
         return field;
@@ -84,6 +83,7 @@ public FieldPredicate<ENTITY> negate() {
     public String toString() {
         final ColumnIdentifier<ENTITY> cId = field.identifier();
         final StringBuilder sb = new StringBuilder();
+
         sb.append(getClass().getSimpleName())
             .append(" {")
             .append("field: ")
@@ -93,15 +93,13 @@ public String toString() {
             .append(cId.getColumnName())
             .append(", type: '").append(predicateType).append("'");
 
-        Cast.cast(this, Tuple.class)
-            .ifPresent(tuple -> {
-                for (int i = 0; i < tuple.length(); i++) {
-                    sb.append(", operand ").append(i).append(": ").append(tuple.get(i));
-                }
-            });
+        Cast.cast(this, Tuple.class).ifPresent(tuple -> {
+            for (int i = 0; i < tuple.degree(); i++) {
+                sb.append(", operand ").append(i)
+                    .append(": ").append(tuple.get(i));
+            }
+        });
 
-        sb.append(", negated: ").append(isNegated())
-            .append("}");
-        return sb.toString();
+        return sb.append("}").toString();
     }
 }

runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/predicate/AbstractPredicate.java

@@ -17,10 +17,11 @@
 package com.speedment.runtime.field.internal.predicate;
 
 import com.speedment.runtime.field.predicate.CombinedPredicate;
-import com.speedment.runtime.field.predicate.trait.HasNegated;
-import static java.util.Objects.requireNonNull;
+
 import java.util.function.Predicate;
 
+import static java.util.Objects.requireNonNull;
+
 /**
  * This class represents a Predicate that is used to build up higher orders
  * of predicates.
@@ -30,13 +31,9 @@
  * @author  Per Minborg
  * @since   2.1.0
  */
-abstract class AbstractPredicate<T> implements HasNegated, Predicate<T> {
-
-    private final boolean negated;
+abstract class AbstractPredicate<T> implements Predicate<T> {
 
-    AbstractPredicate(boolean negated) {
-        this.negated = negated;
-    }
+    AbstractPredicate() {}
 
     @Override
     public Predicate<T> and(Predicate<? super T> other) {
@@ -49,24 +46,4 @@ public Predicate<T> or(Predicate<? super T> other) {
         requireNonNull(other);
         return CombinedPredicate.or(this, other);
     }
-
-    @Override
-    public boolean isNegated() {
-        return negated;
-    }
-
-    @Override
-    public final boolean test(T instance) {
-        return testWithoutNegation(instance) ^ negated;
-    }
-
-    /**
-     * Tests this predicate without applying negation. If the predicate
-     * has been negated, the result from this method will be negated
-     * afterwards.
-     * 
-     * @param instance  the instance to test
-     * @return          the result of the test (without negation)
-     */
-    protected abstract boolean testWithoutNegation(T instance);
 }

runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/predicate/AlwaysFalsePredicate.java

@@ -23,16 +23,15 @@
  * A special implementation of {@code Predicate} that always returns false.
  * 
  * @param <ENTITY>  the entity type
- * @param <V>       the value type
  * @param <FIELD>   the field type
  * 
  * @author  Per Minborg
  * @since   2.2.0
  */
-public final class AlwaysFalsePredicate<ENTITY, V, FIELD extends Field<ENTITY>> 
-        extends AbstractFieldPredicate<ENTITY, V, FIELD> {
+public final class AlwaysFalsePredicate<ENTITY, FIELD extends Field<ENTITY>>
+extends AbstractFieldPredicate<ENTITY, FIELD> {
 
     public AlwaysFalsePredicate(FIELD field) {
-        super(PredicateType.ALWAYS_FALSE, field, entity -> false, false);
+        super(PredicateType.ALWAYS_FALSE, field, entity -> false);
     }
 }

runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/predicate/AlwaysTruePredicate.java

@@ -23,16 +23,15 @@
  * A special implementation of {@code Predicate} that always returns true.
  * 
  * @param <ENTITY>  the entity type
- * @param <V>       the value type
  * @param <FIELD>   the field type
  * 
  * @author  Per Minborg
  * @since   2.2.0
  */
-public final class AlwaysTruePredicate<ENTITY, V, FIELD extends Field<ENTITY>> 
-        extends AbstractFieldPredicate<ENTITY, V, FIELD> {
+public final class AlwaysTruePredicate<ENTITY, FIELD extends Field<ENTITY>>
+extends AbstractFieldPredicate<ENTITY, FIELD> {
 
     public AlwaysTruePredicate(FIELD field) {
-        super(PredicateType.ALWAYS_TRUE, field, entity -> true, false);
+        super(PredicateType.ALWAYS_TRUE, field, entity -> true);
     }
-}
+}

runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/predicate/bytes/ByteBetweenPredicate.java

@@ -35,18 +35,17 @@
  * @since  3.0.0
  */
 @GeneratedCode(value = "Speedment")
-public final class ByteBetweenPredicate<ENTITY, D> extends AbstractFieldPredicate<ENTITY, Byte, HasByteValue<ENTITY, D>> implements BetweenPredicate, Tuple2<Byte, Byte> {
+public final class ByteBetweenPredicate<ENTITY, D> extends AbstractFieldPredicate<ENTITY, HasByteValue<ENTITY, D>> implements BetweenPredicate, Tuple2<Byte, Byte> {
 
     private final byte start;
     private final byte end;
     private final Inclusion inclusion;
 
-    ByteBetweenPredicate(
+    public ByteBetweenPredicate(
             HasByteValue<ENTITY, D> field,
             byte start,
             byte end,
-            Inclusion inclusion,
-            boolean negated) {
+            Inclusion inclusion) {
         super(PredicateType.BETWEEN, field, entity -> {
             final byte fieldValue = field.getAsByte(entity);
 
@@ -65,21 +64,13 @@ public final class ByteBetweenPredicate<ENTITY, D> extends AbstractFieldPredicat
 
                 default : throw new IllegalStateException("Inclusion unknown: " + inclusion);
             }
-        }, negated);
+        });
 
         this.start     = start;
         this.end       = end;
         this.inclusion = requireNonNull(inclusion);
     }
 
-    public ByteBetweenPredicate(
-            HasByteValue<ENTITY, D> field,
-            byte start,
-            byte end,
-            Inclusion inclusion) {
-        this(field, start, end, inclusion, false);
-    }
-
     @Override
     public Byte get0() {
         return start;
@@ -96,7 +87,7 @@ public Inclusion getInclusion() {
     }
 
     @Override
-    public ByteBetweenPredicate<ENTITY, D> negate() {
-        return new ByteBetweenPredicate<>(getField(), start, end, inclusion, !isNegated());
+    public ByteNotBetweenPredicate<ENTITY, D> negate() {
+        return new ByteNotBetweenPredicate<>(getField(), start, end, inclusion);
     }
 }

runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/predicate/bytes/ByteEqualPredicate.java

@@ -30,16 +30,12 @@
  * @since  3.0.0
  */
 @GeneratedCode(value = "Speedment")
-public final class ByteEqualPredicate<ENTITY, D> extends AbstractFieldPredicate<ENTITY, Byte, HasByteValue<ENTITY, D>> implements Tuple1<Byte> {
+public final class ByteEqualPredicate<ENTITY, D> extends AbstractFieldPredicate<ENTITY, HasByteValue<ENTITY, D>> implements Tuple1<Byte> {
 
     private final byte value;
 
     public ByteEqualPredicate(HasByteValue<ENTITY, D> field, byte value) {
-        this(field, value, false);
-    }
-
-    ByteEqualPredicate(HasByteValue<ENTITY, D> field, byte value, boolean negated) {
-        super(PredicateType.EQUAL, field, entity -> field.getAsByte(entity) == value, negated);
+        super(PredicateType.EQUAL, field, entity -> field.getAsByte(entity) == value);
         this.value = value;
     }
 
@@ -49,7 +45,7 @@ public Byte get0() {
     }
 
     @Override
-    public ByteEqualPredicate<ENTITY, D> negate() {
-        return new ByteEqualPredicate<>(getField(), value, !isNegated());
+    public ByteNotEqualPredicate<ENTITY, D> negate() {
+        return new ByteNotEqualPredicate<>(getField(), value);
     }
 }

runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/predicate/bytes/ByteGreaterOrEqualPredicate.java

@@ -30,16 +30,12 @@
  * @since  3.0.0
  */
 @GeneratedCode(value = "Speedment")
-public final class ByteGreaterOrEqualPredicate<ENTITY, D> extends AbstractFieldPredicate<ENTITY, Byte, HasByteValue<ENTITY, D>> implements Tuple1<Byte> {
+public final class ByteGreaterOrEqualPredicate<ENTITY, D> extends AbstractFieldPredicate<ENTITY, HasByteValue<ENTITY, D>> implements Tuple1<Byte> {
 
     private final byte value;
 
     public ByteGreaterOrEqualPredicate(HasByteValue<ENTITY, D> field, byte value) {
-        this(field, value, false);
-    }
-
-    ByteGreaterOrEqualPredicate(HasByteValue<ENTITY, D> field, byte value, boolean negated) {
-        super(PredicateType.GREATER_OR_EQUAL, field, entity -> field.getAsByte(entity) >= value, negated);
+        super(PredicateType.GREATER_OR_EQUAL, field, entity -> field.getAsByte(entity) >= value);
         this.value = value;
     }
 
@@ -49,7 +45,7 @@ public Byte get0() {
     }
 
     @Override
-    public ByteGreaterOrEqualPredicate<ENTITY, D> negate() {
-        return new ByteGreaterOrEqualPredicate<>(getField(), value, !isNegated());
+    public ByteLessThanPredicate<ENTITY, D> negate() {
+        return new ByteLessThanPredicate<>(getField(), value);
     }
 }