com.speedment.runtime.field.internal.EnumForeignKeyFieldImpl Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of runtime-field Show documentation
Show all versions of runtime-field Show documentation
Partly generated model of the fields that represent columns in the
database. Fields can be used to produce special predicates and functions
that contain metadata that Speedment can analyze runtime.
/**
*
* Copyright (c) 2006-2017, Speedment, Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"); You may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.speedment.runtime.field.internal;
import com.speedment.runtime.config.identifier.ColumnIdentifier;
import com.speedment.runtime.config.identifier.TableIdentifier;
import com.speedment.runtime.field.EnumForeignKeyField;
import com.speedment.runtime.field.comparator.FieldComparator;
import com.speedment.runtime.field.comparator.NullOrder;
import com.speedment.runtime.field.internal.comparator.ReferenceFieldComparatorImpl;
import com.speedment.runtime.field.internal.method.BackwardFinderImpl;
import com.speedment.runtime.field.internal.method.FindFromNullableReference;
import com.speedment.runtime.field.internal.method.FindFromReference;
import com.speedment.runtime.field.internal.predicate.AlwaysFalsePredicate;
import com.speedment.runtime.field.internal.predicate.reference.ReferenceEqualPredicate;
import com.speedment.runtime.field.internal.predicate.reference.ReferenceInPredicate;
import com.speedment.runtime.field.internal.predicate.reference.ReferenceIsNotNullPredicate;
import com.speedment.runtime.field.internal.predicate.reference.ReferenceIsNullPredicate;
import com.speedment.runtime.field.method.*;
import com.speedment.runtime.field.predicate.Inclusion;
import com.speedment.runtime.field.trait.HasComparableOperators;
import com.speedment.runtime.typemapper.TypeMapper;
import java.util.Collection;
import java.util.EnumSet;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Stream;
import static java.util.Objects.requireNonNull;
/**
* Default implementation of the {@link EnumForeignKeyField}-interface.
*
* @author Emil Forslund
* @since 3.0.10
*/
public final class EnumForeignKeyFieldImpl
, FK>
implements EnumForeignKeyField {
private final ColumnIdentifier identifier;
private final ReferenceGetter getter;
private final ReferenceSetter setter;
private final TypeMapper typeMapper;
private final HasComparableOperators referenced;
private final Function enumToString;
private final Function stringToEnum;
private final Class enumClass;
private final EnumSet constants;
public EnumForeignKeyFieldImpl(ColumnIdentifier identifier,
ReferenceGetter getter,
ReferenceSetter setter,
TypeMapper typeMapper,
HasComparableOperators referenced,
Function enumToString,
Function stringToEnum,
Class enumClass) {
this.identifier = requireNonNull(identifier);
this.getter = requireNonNull(getter);
this.setter = requireNonNull(setter);
this.typeMapper = requireNonNull(typeMapper);
this.referenced = requireNonNull(referenced);
this.enumToString = requireNonNull(enumToString);
this.stringToEnum = requireNonNull(stringToEnum);
this.enumClass = requireNonNull(enumClass);
this.constants = EnumSet.allOf(enumClass);
}
////////////////////////////////////////////////////////////////////////////
// Getters //
////////////////////////////////////////////////////////////////////////////
@Override
public Class enumClass() {
return enumClass;
}
@Override
public EnumSet constants() {
return EnumSet.allOf(enumClass);
}
@Override
public ColumnIdentifier identifier() {
return identifier;
}
@Override
public ReferenceSetter setter() {
return setter;
}
@Override
public ReferenceGetter getter() {
return getter;
}
@Override
public TypeMapper typeMapper() {
return typeMapper;
}
@Override
public Function stringToEnum() {
return stringToEnum;
}
@Override
public Function enumToString() {
return enumToString;
}
@Override
public boolean isUnique() {
return false;
}
@Override
public HasComparableOperators getReferencedField() {
return referenced;
}
@Override
public BackwardFinder
backwardFinder(TableIdentifier identifier,
Supplier> streamSupplier) {
return new BackwardFinderImpl<>(this, identifier, streamSupplier);
}
@Override
public FindFrom finder(TableIdentifier identifier,
Supplier> streamSupplier) {
return new FindFromReference<>(
this, referenced, identifier, streamSupplier
);
}
@Override
public FindFromNullable nullableFinder(
TableIdentifier identifier,
Supplier> streamSupplier) {
return new FindFromNullableReference<>(
this, referenced, identifier, streamSupplier
);
}
////////////////////////////////////////////////////////////////////////////
// Comparators //
////////////////////////////////////////////////////////////////////////////
@Override
public FieldComparator comparator() {
return new ReferenceFieldComparatorImpl<>(this, NullOrder.LAST);
}
@Override
public FieldComparator comparatorNullFieldsFirst() {
return new ReferenceFieldComparatorImpl<>(this, NullOrder.FIRST);
}
@Override
public FieldComparator comparatorNullFieldsLast() {
return comparator();
}
////////////////////////////////////////////////////////////////////////////
// Predicates //
////////////////////////////////////////////////////////////////////////////
@Override
public Predicate isNull() {
return new ReferenceIsNullPredicate<>(this);
}
@Override
public Predicate isNotNull() {
return new ReferenceIsNotNullPredicate<>(this);
}
@Override
public Predicate equal(E value) {
return toEntityPredicate(e -> e != null && e.compareTo(value) == 0);
}
@Override
public Predicate notEqual(E value) {
return toEntityPredicate(e -> e != null && e.compareTo(value) != 0);
}
@Override
public Predicate lessThan(E value) {
return toEntityPredicate(e -> e != null && e.compareTo(value) < 0);
}
@Override
public Predicate lessOrEqual(E value) {
return toEntityPredicate(e -> e != null && e.compareTo(value) <= 0);
}
@Override
public Predicate greaterThan(E value) {
return toEntityPredicate(e -> e != null && e.compareTo(value) > 0);
}
@Override
public Predicate greaterOrEqual(E value) {
return toEntityPredicate(e -> e != null && e.compareTo(value) >= 0);
}
@Override
public Predicate between(E start, E end, Inclusion inclusion) {
return toEntityPredicate(e -> {
switch (inclusion) {
case START_EXCLUSIVE_END_EXCLUSIVE:
return e.compareTo(start) > 0 && e.compareTo(end) < 0;
case START_EXCLUSIVE_END_INCLUSIVE:
return e.compareTo(start) > 0 && e.compareTo(end) <= 0;
case START_INCLUSIVE_END_EXCLUSIVE:
return e.compareTo(start) >= 0 && e.compareTo(end) < 0;
case START_INCLUSIVE_END_INCLUSIVE:
return e.compareTo(start) >= 0 && e.compareTo(end) <= 0;
default : throw new UnsupportedOperationException(
"Unknown inclusion '" + inclusion + "'."
);
}
});
}
@Override
public Predicate notBetween(E start, E end, Inclusion inclusion) {
return toEntityPredicate(e -> {
switch (inclusion) {
case START_EXCLUSIVE_END_EXCLUSIVE:
return e.compareTo(start) <= 0 || e.compareTo(end) >= 0;
case START_EXCLUSIVE_END_INCLUSIVE:
return e.compareTo(start) <= 0 || e.compareTo(end) > 0;
case START_INCLUSIVE_END_EXCLUSIVE:
return e.compareTo(start) < 0 || e.compareTo(end) >= 0;
case START_INCLUSIVE_END_INCLUSIVE:
return e.compareTo(start) < 0 || e.compareTo(end) > 0;
default : throw new UnsupportedOperationException(
"Unknown inclusion '" + inclusion + "'."
);
}
});
}
@Override
public Predicate in(Collection values) {
return toEntityPredicate(values::contains);
}
@Override
public Predicate notIn(Collection values) {
return toEntityPredicate(e -> !values.contains(e));
}
////////////////////////////////////////////////////////////////////////////
// String Predicates //
////////////////////////////////////////////////////////////////////////////
@Override
public Predicate equal(String value) {
return toEntityPredicate(e -> value.equals(enumToString.apply(e)));
}
@Override
public Predicate notEqual(String value) {
return toEntityPredicate(e -> !value.equals(enumToString.apply(e)));
}
@Override
public Predicate lessThan(String value) {
return toEntityPredicate(e -> {
final String str = enumToString.apply(e);
return str != null && str.compareTo(value) < 0;
});
}
@Override
public Predicate lessOrEqual(String value) {
return toEntityPredicate(e -> {
final String str = enumToString.apply(e);
return str != null && str.compareTo(value) <= 0;
});
}
@Override
public Predicate greaterThan(String value) {
return toEntityPredicate(e -> {
final String str = enumToString.apply(e);
return str != null && str.compareTo(value) > 0;
});
}
@Override
public Predicate greaterOrEqual(String value) {
return toEntityPredicate(e -> {
final String str = enumToString.apply(e);
return str != null && str.compareTo(value) >= 0;
});
}
@Override
public Predicate between(String start, String end, Inclusion inclusion) {
return toEntityPredicate(e -> {
final String str = enumToString.apply(e);
if (str == null) return false;
switch (inclusion) {
case START_EXCLUSIVE_END_EXCLUSIVE:
return str.compareTo(start) > 0 && str.compareTo(end) < 0;
case START_EXCLUSIVE_END_INCLUSIVE:
return str.compareTo(start) > 0 && str.compareTo(end) <= 0;
case START_INCLUSIVE_END_EXCLUSIVE:
return str.compareTo(start) >= 0 && str.compareTo(end) < 0;
case START_INCLUSIVE_END_INCLUSIVE:
return str.compareTo(start) >= 0 && str.compareTo(end) <= 0;
default : throw new UnsupportedOperationException(
"Unknown inclusion '" + inclusion + "'."
);
}
});
}
@Override
public Predicate notBetween(String start, String end, Inclusion inclusion) {
return toEntityPredicate(e -> {
final String str = enumToString.apply(e);
if (str == null) return false;
switch (inclusion) {
case START_EXCLUSIVE_END_EXCLUSIVE:
return str.compareTo(start) <= 0 || str.compareTo(end) >= 0;
case START_EXCLUSIVE_END_INCLUSIVE:
return str.compareTo(start) <= 0 || str.compareTo(end) > 0;
case START_INCLUSIVE_END_EXCLUSIVE:
return str.compareTo(start) < 0 || str.compareTo(end) >= 0;
case START_INCLUSIVE_END_INCLUSIVE:
return str.compareTo(start) < 0 || str.compareTo(end) > 0;
default : throw new UnsupportedOperationException(
"Unknown inclusion '" + inclusion + "'."
);
}
});
}
@Override
public Predicate isEmpty() {
return toEntityPredicate(e -> "".equals(enumToString.apply(e)));
}
@Override
public Predicate equalIgnoreCase(String value) {
return toEntityPredicate(e -> value.equalsIgnoreCase(enumToString.apply(e)));
}
@Override
public Predicate startsWith(String value) {
return toEntityPredicate(e -> {
final String str = enumToString.apply(e);
return str != null && str.startsWith(value);
});
}
@Override
public Predicate startsWithIgnoreCase(String value) {
return toEntityPredicate(e -> {
final String str = enumToString.apply(e);
return str != null && str.toLowerCase()
.startsWith(value.toLowerCase());
});
}
@Override
public Predicate endsWith(String value) {
return toEntityPredicate(e -> {
final String str = enumToString.apply(e);
return str != null && str.endsWith(value);
});
}
@Override
public Predicate endsWithIgnoreCase(String value) {
return toEntityPredicate(e -> {
final String str = enumToString.apply(e);
return str != null && str.toLowerCase()
.endsWith(value.toLowerCase());
});
}
@Override
public Predicate contains(String value) {
return toEntityPredicate(e -> {
final String str = enumToString.apply(e);
return str != null && str.contains(value);
});
}
@Override
public Predicate containsIgnoreCase(String value) {
return toEntityPredicate(e -> {
final String str = enumToString.apply(e);
return str != null && str.toLowerCase()
.contains(value.toLowerCase());
});
}
@Override
public Predicate isNotEmpty() {
return toEntityPredicate(e -> !"".equals(enumToString.apply(e)));
}
@Override
public Predicate notEqualIgnoreCase(String value) {
return toEntityPredicate(e -> !value.equalsIgnoreCase(enumToString.apply(e)));
}
@Override
public Predicate notStartsWith(String value) {
return toEntityPredicate(e -> {
final String str = enumToString.apply(e);
return str != null && !str.startsWith(value);
});
}
@Override
public Predicate notEndsWith(String value) {
return toEntityPredicate(e -> {
final String str = enumToString.apply(e);
return str != null && !str.endsWith(value);
});
}
@Override
public Predicate notContains(String value) {
return toEntityPredicate(e -> {
final String str = enumToString.apply(e);
return str != null && !str.contains(value);
});
}
@Override
public Predicate notStartsWithIgnoreCase(String value) {
return toEntityPredicate(e -> {
final String str = enumToString.apply(e);
return str != null && !str.toLowerCase()
.startsWith(value.toLowerCase());
});
}
@Override
public Predicate notEndsWithIgnoreCase(String value) {
return toEntityPredicate(e -> {
final String str = enumToString.apply(e);
return str != null && !str.toLowerCase()
.endsWith(value.toLowerCase());
});
}
@Override
public Predicate notContainsIgnoreCase(String value) {
return toEntityPredicate(e -> {
final String str = enumToString.apply(e);
return str != null && !str.toLowerCase()
.contains(value.toLowerCase());
});
}
////////////////////////////////////////////////////////////////////////////
// Internal Methods //
////////////////////////////////////////////////////////////////////////////
private Predicate toEntityPredicate(Predicate predicate) {
final EnumSet valid = evaluate(predicate);
switch (valid.size()) {
case 0 : return new AlwaysFalsePredicate<>(this);
case 1 : return new ReferenceEqualPredicate<>(this, valid.iterator().next());
default : return new ReferenceInPredicate<>(this, valid);
}
}
private EnumSet evaluate(Predicate predicate) {
final EnumSet result = EnumSet.noneOf(enumClass);
constants.stream().filter(predicate).forEach(result::add);
return result;
}
} © 2015 - 2025 Weber Informatics LLC | Privacy Policy