proj_name
stringclasses 131
values | relative_path
stringlengths 30
228
| class_name
stringlengths 1
68
| func_name
stringlengths 1
48
| masked_class
stringlengths 78
9.82k
| func_body
stringlengths 46
9.61k
| len_input
int64 29
2.01k
| len_output
int64 14
1.94k
| total
int64 55
2.05k
| relevant_context
stringlengths 0
38.4k
|
|---|---|---|---|---|---|---|---|---|---|
speedment_speedment
|
speedment/runtime-parent/runtime-compute/src/main/java/com/speedment/runtime/compute/internal/ToByteNullableImpl.java
|
ToByteNullableImpl
|
compare
|
class ToByteNullableImpl<T>
implements NullableExpression<T, ToByte<T>>, ToByteNullable<T> {
private final ToByte<T> original;
private final Predicate<T> isNull;
public ToByteNullableImpl(ToByte<T> original, Predicate<T> isNull) {
this.original = requireNonNull(original);
this.isNull = requireNonNull(isNull);
}
@Override
public ToByte<T> inner() {
return original;
}
@Override
public Predicate<T> isNullPredicate() {
return isNull;
}
@Override
public Byte apply(T t) {
return isNull.test(t) ? null : original.applyAsByte(t);
}
@Override
public byte applyAsByte(T t) {
return original.applyAsByte(t);
}
@Override
public ToByte<T> orThrow() {
return original;
}
@Override
public ToByte<T> orElseGet(ToByte<T> getter) {
return t -> isNull.test(t)
? getter.applyAsByte(t)
: original.applyAsByte(t);
}
@Override
public ToByte<T> orElse(Byte value) {
return t -> isNull.test(t) ? value : original.applyAsByte(t);
}
@Override
public ToDoubleNullable<T> mapToDoubleIfPresent(ByteToDoubleFunction mapper) {
return t -> isNull.test(t) ? null
: mapper.applyAsDouble(original.applyAsByte(t));
}
@Override
public ToByteNullable<T> mapIfPresent(ByteUnaryOperator mapper) {
return t -> isNull.test(t) ? null
: mapper.applyAsByte(original.applyAsByte(t));
}
@Override
public long hash(T object) {
return isNull.test(object)
? (0xff + 1) // Will never occur naturally
: original.applyAsByte(object);
}
@Override
public int compare(T first, T second) {<FILL_FUNCTION_BODY>}
@Override
public boolean isNull(T object) {
return isNull.test(object);
}
@Override
public boolean isNotNull(T object) {
return !isNull.test(object);
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
else if (!(o instanceof NullableExpression)) return false;
final NullableExpression<?, ?> that = (NullableExpression<?, ?>) o;
return Objects.equals(original, that.inner()) &&
Objects.equals(isNull, that.isNullPredicate());
}
@Override
public int hashCode() {
return Objects.hash(original, isNull);
}
}
|
final boolean f = isNull(first);
final boolean s = isNull(second);
if (f && s) return 0;
else if (f) return 1;
else if (s) return -1;
else return Byte.compare(
original.applyAsByte(first),
original.applyAsByte(second)
);
| 768
| 90
| 858
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-compute/src/main/java/com/speedment/runtime/compute/internal/ToEnumNullableImpl.java
|
ToEnumNullableImpl
|
compare
|
class ToEnumNullableImpl<T, E extends Enum<E>>
implements ToEnumNullable<T, E> {
private final Class<E> enumClass;
private final Function<T, E> inner;
public ToEnumNullableImpl(Class<E> enumClass, Function<T, E> inner) {
this.enumClass = requireNonNull(enumClass);
this.inner = requireNonNull(inner);
}
@Override
public Class<E> enumClass() {
return enumClass;
}
@Override
public E apply(T t) {
return inner.apply(t);
}
@Override
public ToIntNullable<T> asOrdinal() {
return object -> isNotNull(object)
? apply(object).ordinal()
: null;
}
@Override
public ToStringNullable<T> asName() {
return object -> isNotNull(object)
? apply(object).name()
: null;
}
@Override
public long hash(T object) {
return object == null ? 0 : object.hashCode();
}
@Override
public int compare(T first, T second) {<FILL_FUNCTION_BODY>}
}
|
final E f = apply(first);
final E s = apply(second);
if (f == null && s == null) {
return 0;
} else if (f == null) {
return 1;
} else if (s == null) {
return -1;
} else {
return Integer.compare(f.ordinal(), s.ordinal());
}
| 319
| 101
| 420
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-compute/src/main/java/com/speedment/runtime/compute/internal/ToFloatNullableImpl.java
|
ToFloatNullableImpl
|
compare
|
class ToFloatNullableImpl<T>
implements NullableExpression<T, ToFloat<T>>, ToFloatNullable<T> {
private final ToFloat<T> original;
private final Predicate<T> isNull;
public ToFloatNullableImpl(ToFloat<T> original, Predicate<T> isNull) {
this.original = requireNonNull(original);
this.isNull = requireNonNull(isNull);
}
@Override
public ToFloat<T> inner() {
return original;
}
@Override
public Predicate<T> isNullPredicate() {
return isNull;
}
@Override
public Float apply(T t) {
return isNull.test(t) ? null : original.applyAsFloat(t);
}
@Override
public float applyAsFloat(T t) {
return original.applyAsFloat(t);
}
@Override
public ToFloat<T> orThrow() {
return original;
}
@Override
public ToFloat<T> orElseGet(ToFloat<T> getter) {
return t -> isNull.test(t)
? getter.applyAsFloat(t)
: original.applyAsFloat(t);
}
@Override
public ToFloat<T> orElse(Float value) {
return t -> isNull.test(t) ? value : original.applyAsFloat(t);
}
@Override
public ToDoubleNullable<T> mapToDoubleIfPresent(FloatToDoubleFunction mapper) {
return t -> isNull.test(t) ? null
: mapper.applyAsDouble(original.applyAsFloat(t));
}
@Override
public ToFloatNullable<T> mapIfPresent(FloatUnaryOperator mapper) {
return t -> isNull.test(t) ? null
: mapper.applyAsFloat(original.applyAsFloat(t));
}
@Override
public long hash(T object) {
return isNull.test(object)
? (0xffffffffL + 1) // Will never occur naturally
: Float.floatToIntBits(original.applyAsFloat(object));
}
@Override
public int compare(T first, T second) {<FILL_FUNCTION_BODY>}
@Override
public boolean isNull(T object) {
return isNull.test(object);
}
@Override
public boolean isNotNull(T object) {
return !isNull.test(object);
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
else if (!(o instanceof NullableExpression)) return false;
final NullableExpression<?, ?> that = (NullableExpression<?, ?>) o;
return Objects.equals(original, that.inner()) &&
Objects.equals(isNull, that.isNullPredicate());
}
@Override
public int hashCode() {
return Objects.hash(original, isNull);
}
}
|
final boolean f = isNull(first);
final boolean s = isNull(second);
if (f && s) return 0;
else if (f) return 1;
else if (s) return -1;
else return Float.compare(
original.applyAsFloat(first),
original.applyAsFloat(second)
);
| 780
| 91
| 871
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-compute/src/main/java/com/speedment/runtime/compute/internal/ToLongNullableImpl.java
|
ToLongNullableImpl
|
equals
|
class ToLongNullableImpl<T>
implements NullableExpression<T, ToLong<T>>, ToLongNullable<T> {
private final ToLong<T> original;
private final Predicate<T> isNull;
public ToLongNullableImpl(ToLong<T> original, Predicate<T> isNull) {
this.original = requireNonNull(original);
this.isNull = requireNonNull(isNull);
}
@Override
public ToLong<T> inner() {
return original;
}
@Override
public Predicate<T> isNullPredicate() {
return isNull;
}
@Override
public Long apply(T t) {
return isNull.test(t) ? null : original.applyAsLong(t);
}
@Override
public long applyAsLong(T t) {
return original.applyAsLong(t);
}
@Override
public ToLong<T> orThrow() {
return original;
}
@Override
public ToLong<T> orElseGet(ToLong<T> getter) {
return t -> isNull.test(t)
? getter.applyAsLong(t)
: original.applyAsLong(t);
}
@Override
public ToLong<T> orElse(Long value) {
return t -> isNull.test(t) ? value : original.applyAsLong(t);
}
@Override
public ToDoubleNullable<T> mapToDoubleIfPresent(LongToDoubleFunction mapper) {
return t -> isNull.test(t) ? null
: mapper.applyAsDouble(original.applyAsLong(t));
}
@Override
public ToLongNullable<T> mapIfPresent(LongUnaryOperator mapper) {
return t -> isNull.test(t) ? null
: mapper.applyAsLong(original.applyAsLong(t));
}
@Override
public long hash(T object) {
return isNull.test(object)
? 0xffffffffffffffffL
: original.applyAsLong(object);
}
@Override
public int compare(T first, T second) {
final boolean f = isNull(first);
final boolean s = isNull(second);
if (f && s) return 0;
else if (f) return 1;
else if (s) return -1;
else return Long.compare(
original.applyAsLong(first),
original.applyAsLong(second)
);
}
@Override
public boolean isNull(T object) {
return isNull.test(object);
}
@Override
public boolean isNotNull(T object) {
return !isNull.test(object);
}
@Override
public boolean equals(Object o) {<FILL_FUNCTION_BODY>}
@Override
public int hashCode() {
return Objects.hash(original, isNull);
}
}
|
if (this == o) return true;
else if (!(o instanceof NullableExpression)) return false;
final NullableExpression<?, ?> that = (NullableExpression<?, ?>) o;
return Objects.equals(original, that.inner()) &&
Objects.equals(isNull, that.isNullPredicate());
| 771
| 83
| 854
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-compute/src/main/java/com/speedment/runtime/compute/internal/ToShortNullableImpl.java
|
ToShortNullableImpl
|
equals
|
class ToShortNullableImpl<T>
implements NullableExpression<T, ToShort<T>>, ToShortNullable<T> {
private final ToShort<T> original;
private final Predicate<T> isNull;
public ToShortNullableImpl(ToShort<T> original, Predicate<T> isNull) {
this.original = requireNonNull(original);
this.isNull = requireNonNull(isNull);
}
@Override
public ToShort<T> inner() {
return original;
}
@Override
public Predicate<T> isNullPredicate() {
return isNull;
}
@Override
public Short apply(T t) {
return isNull.test(t) ? null : original.applyAsShort(t);
}
@Override
public short applyAsShort(T t) {
return original.applyAsShort(t);
}
@Override
public ToShort<T> orThrow() {
return original;
}
@Override
public ToShort<T> orElseGet(ToShort<T> getter) {
return t -> isNull.test(t)
? getter.applyAsShort(t)
: original.applyAsShort(t);
}
@Override
public ToShort<T> orElse(Short value) {
return t -> isNull.test(t) ? value : original.applyAsShort(t);
}
@Override
public ToDoubleNullable<T> mapToDoubleIfPresent(ShortToDoubleFunction mapper) {
return t -> isNull.test(t) ? null
: mapper.applyAsDouble(original.applyAsShort(t));
}
@Override
public ToShortNullable<T> mapIfPresent(ShortUnaryOperator mapper) {
return t -> isNull.test(t) ? null
: mapper.applyAsShort(original.applyAsShort(t));
}
@Override
public long hash(T object) {
return isNull.test(object)
? (0xffff + 1) // Will never occur naturally
: original.applyAsShort(object);
}
@Override
public int compare(T first, T second) {
final boolean f = isNull(first);
final boolean s = isNull(second);
if (f && s) return 0;
else if (f) return 1;
else if (s) return -1;
else return Short.compare(
original.applyAsShort(first),
original.applyAsShort(second)
);
}
@Override
public boolean isNull(T object) {
return isNull.test(object);
}
@Override
public boolean isNotNull(T object) {
return !isNull.test(object);
}
@Override
public boolean equals(Object o) {<FILL_FUNCTION_BODY>}
@Override
public int hashCode() {
return Objects.hash(original, isNull);
}
}
|
if (this == o) return true;
else if (!(o instanceof NullableExpression)) return false;
final NullableExpression<?, ?> that = (NullableExpression<?, ?>) o;
return Objects.equals(original, that.inner()) &&
Objects.equals(isNull, that.isNullPredicate());
| 775
| 83
| 858
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-compute/src/main/java/com/speedment/runtime/compute/internal/expression/AbsUtil.java
|
AbsLong
|
applyAsLong
|
class AbsLong extends AbstractAbs<T, ToLong<T>> implements ToLong<T> {
private AbsLong(ToLong<T> inner) {
super(inner);
}
@Override
public long applyAsLong(T object) {<FILL_FUNCTION_BODY>}
}
|
final long value = inner.applyAsLong(object);
return value < 0 ? -value : value;
| 77
| 29
| 106
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-compute/src/main/java/com/speedment/runtime/compute/internal/expression/CastUtil.java
|
DoubleToLong
|
castBigDecimalToLong
|
class DoubleToLong extends CastToLong<T, ToDouble<T>> {
private DoubleToLong(ToDouble<T> tToDouble) {
super(tToDouble);
}
@Override
public long applyAsLong(T object) {
return (long) inner.applyAsDouble(object);
}
}
return new DoubleToLong(original);
}
/**
* Returns an expression that wraps the specified expression and casts the
* result from it into a {@code long}.
*
* @param original the original expression
* @param <T> the input type
* @return the new {@link ToInt} expression
*/
public static <T> ToLong<T> castBigDecimalToLong(ToBigDecimal<T> original) {<FILL_FUNCTION_BODY>
|
class BigDecimalToLong extends CastToLong<T, ToBigDecimal<T>> {
private BigDecimalToLong(ToBigDecimal<T> tToBigDecimal) {
super(tToBigDecimal);
}
@Override
public long applyAsLong(T object) {
return inner.apply(object).longValueExact();
}
}
return new BigDecimalToLong(original);
| 212
| 112
| 324
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-compute/src/main/java/com/speedment/runtime/compute/internal/expression/ComposedUtil.java
|
ComposeToBoolean
|
applyAsBoolean
|
class ComposeToBoolean<T, A, AFTER extends ToBooleanFunction<A> & Expression<A>>
implements ComposedExpression<T, A>, ToBoolean<T> {
private final Function<T, A> before;
private final AFTER after;
ComposeToBoolean(Function<T, A> before, AFTER after) {
this.before = requireNonNull(before);
this.after = requireNonNull(after);
}
@Override
public Function<T, A> firstStep() {
return before;
}
@Override
public AFTER secondStep() {
return after;
}
@Override
public boolean applyAsBoolean(T object) {<FILL_FUNCTION_BODY>}
}
|
final A intermediate = before.apply(object);
return intermediate != null && after.applyAsBoolean(intermediate);
| 193
| 32
| 225
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-compute/src/main/java/com/speedment/runtime/compute/internal/expression/MapperUtil.java
|
AbstractMapper
|
equals
|
class AbstractMapper<T, INNER extends Expression<T>, MAPPER>
implements MapperExpression<T, INNER, MAPPER> {
final INNER inner;
final MAPPER mapper;
AbstractMapper(INNER inner, MAPPER mapper) {
this.inner = requireNonNull(inner);
this.mapper = requireNonNull(mapper);
}
@Override
public final INNER inner() {
return inner;
}
@Override
public final MAPPER mapper() {
return mapper;
}
@Override
public final boolean equals(Object o) {<FILL_FUNCTION_BODY>}
@Override
public final int hashCode() {
return Objects.hash(inner(), mapper(), mapperType());
}
}
|
if (this == o) return true;
else if (!(o instanceof MapperExpression)) return false;
final MapperExpression<?, ?, ?> that = (MapperExpression<?, ?, ?>) o;
return Objects.equals(inner(), that.inner()) &&
Objects.equals(mapper(), that.mapper()) &&
Objects.equals(mapperType(), that.mapperType());
| 211
| 103
| 314
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-compute/src/main/java/com/speedment/runtime/compute/internal/expression/MinusUtil.java
|
LongMinusInt
|
longMinusLong
|
class LongMinusInt extends AbstractMinus<T, ToLong<T>, ToInt<T>> implements ToLong<T> {
private LongMinusInt(ToLong<T> first, ToInt<T> second) {
super(first, second);
}
@Override
public long applyAsLong(T object) {
return firstInner.applyAsLong(object)
- secondInner.applyAsInt(object);
}
}
return new LongMinusInt(first, second);
}
/**
* Creates and returns an expression that takes the result of the two
* expressions and add them together.
*
* @param first the first input expression
* @param second the second input expression
* @param <T> the input type
* @return the new expression
*/
public static <T> ToLong<T> longMinusLong(ToLong<T> first, ToLong<T> second) {<FILL_FUNCTION_BODY>
|
class LongMinusLong extends AbstractMinus<T, ToLong<T>, ToLong<T>> implements ToLong<T> {
private LongMinusLong(ToLong<T> first, ToLong<T> second) {
super(first, second);
}
@Override
public long applyAsLong(T object) {
return firstInner.applyAsLong(object)
- secondInner.applyAsLong(object);
}
}
return new LongMinusLong(first, second);
| 250
| 130
| 380
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-compute/src/main/java/com/speedment/runtime/compute/internal/expression/OrElseGetUtil.java
|
AbstractNonNullable
|
equals
|
class AbstractNonNullable
<T, INNER extends Expression<T>, DEFAULT extends Expression<T>>
implements OrElseGetExpression<T, INNER, DEFAULT> {
final INNER inner;
final DEFAULT getter;
AbstractNonNullable(INNER inner, DEFAULT getter) {
this.inner = requireNonNull(inner);
this.getter = requireNonNull(getter);
}
@Override
public final INNER innerNullable() {
return inner;
}
@Override
public final DEFAULT defaultValueGetter() {
return getter;
}
@Override
public final boolean equals(Object o) {<FILL_FUNCTION_BODY>}
@Override
public final int hashCode() {
return Objects.hash(inner, getter);
}
}
|
if (this == o) return true;
if (!(o instanceof OrElseGetExpression)) return false;
final OrElseGetExpression<?, ?, ?> that = (OrElseGetExpression<?, ?, ?>) o;
return Objects.equals(inner, that.innerNullable()) &&
Objects.equals(getter, that.defaultValueGetter());
| 211
| 94
| 305
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-compute/src/main/java/com/speedment/runtime/compute/internal/expression/SignUtil.java
|
ShortSign
|
applyAsByte
|
class ShortSign extends AbstractSign<T, ToShort<T>> {
private ShortSign(ToShort<T> tToShort) {
super(tToShort);
}
@Override
public byte applyAsByte(T object) {<FILL_FUNCTION_BODY>}
}
|
final short value = inner.applyAsShort(object);
if (value < 0) {
return NEGATIVE;
} else {
return value > 0 ? POSITIVE : ZERO;
}
| 75
| 58
| 133
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-compute/src/main/java/com/speedment/runtime/compute/internal/expression/SqrtUtil.java
|
IntSqrt
|
sqrtLong
|
class IntSqrt extends AbstractSqrt<T, ToInt<T>> {
private IntSqrt(ToInt<T> tToInt) {
super(tToInt);
}
@Override
public double applyAsDouble(T object) {
return Math.sqrt(inner.applyAsInt(object));
}
}
return new IntSqrt(other);
}
/**
* Returns an expression that takes the result from the specified expression
* and returns the positive square root of it.
*
* @param other the expression to take the square root of
* @param <T> the input entity type
* @return expression for the square root
*/
public static <T> ToDouble<T> sqrtLong(ToLong<T> other) {<FILL_FUNCTION_BODY>
|
class LongSqrt extends AbstractSqrt<T, ToLong<T>> {
private LongSqrt(ToLong<T> tToLong) {
super(tToLong);
}
@Override
public double applyAsDouble(T object) {
return Math.sqrt(inner.applyAsLong(object));
}
}
return new LongSqrt(other);
| 212
| 103
| 315
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-config/src/main/java/com/speedment/runtime/config/internal/AbstractChildDocument.java
|
AbstractChildDocument
|
getParent
|
class AbstractChildDocument<PARENT extends Document>
extends BaseDocument implements HasParent<PARENT> {
AbstractChildDocument(PARENT parent, Map<String, Object> data) {
super(parent, data);
}
@Override
public Optional<PARENT> getParent() {<FILL_FUNCTION_BODY>}
@Override
public String toString() {
return toStringHelper(this);
}
}
|
@SuppressWarnings("unchecked")
final Optional<PARENT> parent = (Optional<PARENT>) super.getParent();
return parent;
| 113
| 42
| 155
|
<methods>public void <init>(com.speedment.runtime.config.Document, Map<java.lang.String,java.lang.Object>) ,public Stream<com.speedment.runtime.config.Document> children() ,public Optional<java.lang.Object> get(java.lang.String) ,public com.speedment.common.function.OptionalBoolean getAsBoolean(java.lang.String) ,public java.util.OptionalDouble getAsDouble(java.lang.String) ,public java.util.OptionalInt getAsInt(java.lang.String) ,public java.util.OptionalLong getAsLong(java.lang.String) ,public Optional<java.lang.String> getAsString(java.lang.String) ,public Map<java.lang.String,java.lang.Object> getData() ,public Optional<? extends com.speedment.runtime.config.Document> getParent() ,public void put(java.lang.String, java.lang.Object) <variables>private final non-sealed Map<java.lang.String,java.lang.Object> config,private final non-sealed com.speedment.runtime.config.Document parent
|
speedment_speedment
|
speedment/runtime-parent/runtime-config/src/main/java/com/speedment/runtime/config/internal/ColumnLabelImpl.java
|
ColumnLabelImpl
|
toString
|
class ColumnLabelImpl implements ColumnLabel {
private final String label;
public ColumnLabelImpl(ColumnIdentifier<?> identifier) {
label = identifier.getDbmsId() + "." +
identifier.getSchemaId() + "." +
identifier.getTableId() + "." +
identifier.getColumnId();
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
final ColumnLabelImpl that = (ColumnLabelImpl) o;
return label.equals(that.label);
}
@Override
public int hashCode() {
return label.hashCode();
}
@Override
public String toString() {<FILL_FUNCTION_BODY>}
}
|
return "ColumnLabelImpl{" +
"label='" + label + '\'' +
'}';
| 221
| 29
| 250
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-config/src/main/java/com/speedment/runtime/config/internal/identifier/ColumnIdentifierImpl.java
|
ColumnIdentifierImpl
|
hashCode
|
class ColumnIdentifierImpl<ENTITY>
implements ColumnIdentifier<ENTITY> {
private final String dbmsName;
private final String schemaName;
private final String tableName;
private final String columnName;
public ColumnIdentifierImpl(
final String dbmsName,
final String schemaName,
final String tableName,
final String columnName) {
this.dbmsName = requireNonNull(dbmsName);
this.schemaName = requireNonNull(schemaName);
this.tableName = requireNonNull(tableName);
this.columnName = requireNonNull(columnName);
}
@Override
public String getDbmsId() {
return dbmsName;
}
@Override
public String getSchemaId() {
return schemaName;
}
@Override
public String getTableId() {
return tableName;
}
@Override
public String getColumnId() {
return columnName;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof ColumnIdentifier)) return false;
final ColumnIdentifier<?> that = (ColumnIdentifier<?>) o;
return getDbmsId().equals(that.getDbmsId())
&& getSchemaId().equals(that.getSchemaId())
&& getTableId().equals(that.getTableId())
&& getColumnId().equals(that.getColumnId());
}
@Override
public int hashCode() {<FILL_FUNCTION_BODY>}
@Override
public String toString() {
return "ColumnIdentifier{" +
dbmsName + '.' +
schemaName + '.' +
tableName + '.' +
columnName + '}';
}
}
|
int result = getDbmsId().hashCode();
result = 31 * result + getSchemaId().hashCode();
result = 31 * result + getTableId().hashCode();
result = 31 * result + getColumnId().hashCode();
return result;
| 454
| 69
| 523
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-config/src/main/java/com/speedment/runtime/config/internal/identifier/DbmsIdentifierImpl.java
|
DbmsIdentifierImpl
|
equals
|
class DbmsIdentifierImpl<ENTITY> implements DbmsIdentifier<ENTITY> {
private final String dbmsName;
public DbmsIdentifierImpl(String dbmsName) {
this.dbmsName = requireNonNull(dbmsName);
}
@Override
public String getDbmsId() {
return dbmsName;
}
@Override
public int hashCode() {
return dbmsName.hashCode();
}
@Override
public boolean equals(Object obj) {<FILL_FUNCTION_BODY>}
@Override
public String toString() {
return dbmsName;
}
}
|
if (this == obj) {
return true;
}
if (obj instanceof DbmsIdentifier) {
final DbmsIdentifier<?> that = (DbmsIdentifier<?>) obj;
return Objects.equals(dbmsName, that.getDbmsId());
}
return false;
| 169
| 81
| 250
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-config/src/main/java/com/speedment/runtime/config/internal/identifier/SchemaIdentifierImpl.java
|
SchemaIdentifierImpl
|
equals
|
class SchemaIdentifierImpl<ENTITY> implements SchemaIdentifier<ENTITY> {
private final String dbmsName;
private final String schemaName;
private final int hashCode;
public SchemaIdentifierImpl(String dbmsName, String schemaName) {
this.dbmsName = requireNonNull(dbmsName);
this.schemaName = requireNonNull(schemaName);
this.hashCode = privateHashCode();
}
@Override
public String getDbmsId() {
return dbmsName;
}
@Override
public String getSchemaId() {
return schemaName;
}
@Override
public int hashCode() {
return hashCode;
}
@Override
public boolean equals(Object obj) {<FILL_FUNCTION_BODY>}
private int privateHashCode() {
int hash = 5;
hash = 53 * hash + Objects.hashCode(dbmsName);
hash = 53 * hash + Objects.hashCode(schemaName);
return hash;
}
@Override
public String toString() {
return dbmsName + "." + schemaName;
}
}
|
if (this == obj) {
return true;
}
if (obj instanceof SchemaIdentifier) {
final SchemaIdentifier<?> that = (SchemaIdentifier<?>) obj;
return
Objects.equals(dbmsName, that.getDbmsId()) &&
Objects.equals(schemaName, that.getSchemaId());
}
return false;
| 298
| 98
| 396
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-config/src/main/java/com/speedment/runtime/config/internal/identifier/TableIdentifierImpl.java
|
TableIdentifierImpl
|
equals
|
class TableIdentifierImpl<ENTITY> implements TableIdentifier<ENTITY> {
private final String dbmsName;
private final String schemaName;
private final String tableName;
private final int hashCode;
public TableIdentifierImpl(String dbmsName, String schemaName, String tableName) {
this.dbmsName = requireNonNull(dbmsName);
this.schemaName = requireNonNull(schemaName);
this.tableName = requireNonNull(tableName);
this.hashCode = privateHashCode();
}
@Override
public String getDbmsId() {
return dbmsName;
}
@Override
public String getSchemaId() {
return schemaName;
}
@Override
public String getTableId() {
return tableName;
}
@Override
public int hashCode() {
return hashCode;
}
@Override
public boolean equals(Object obj) {<FILL_FUNCTION_BODY>}
private int privateHashCode() {
int hash = 5;
hash = 53 * hash + Objects.hashCode(dbmsName);
hash = 53 * hash + Objects.hashCode(schemaName);
hash = 53 * hash + Objects.hashCode(tableName);
return hash;
}
@Override
public String toString() {
return dbmsName + "." + schemaName + "." + tableName;
}
}
|
if (this == obj) {
return true;
}
if (obj instanceof TableIdentifier) {
final TableIdentifier<?> that = (TableIdentifier<?>) obj;
return Objects.equals(dbmsName, that.getDbmsId())
&& Objects.equals(schemaName, that.getSchemaId())
&& Objects.equals(tableName, that.getTableId());
}
return false;
| 368
| 110
| 478
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-config/src/main/java/com/speedment/runtime/config/internal/immutable/ImmutableForeignKeyColumn.java
|
ImmutableForeignKeyColumn
|
findForeignTable
|
class ImmutableForeignKeyColumn extends ImmutableDocument implements ForeignKeyColumn {
private final String id;
private final String name;
private final int ordinalPosition;
private final String foreignColumnName;
private final String foreignTableName;
private final AtomicReference<ImmutableColumn> foreignColumn;
private final AtomicReference<ImmutableTable> foreignTable;
private final AtomicReference<ImmutableColumn> column;
ImmutableForeignKeyColumn(ImmutableForeignKey parent, Map<String, Object> fkc) {
super(parent, requireKeys(fkc, ForeignKeyColumnUtil.FOREIGN_COLUMN_NAME, ForeignKeyColumnUtil.FOREIGN_TABLE_NAME));
final ForeignKeyColumn prototype = new ForeignKeyColumnImpl(parent, fkc);
this.id = prototype.getId();
this.name = prototype.getName();
this.ordinalPosition = prototype.getOrdinalPosition();
this.foreignTableName = prototype.getForeignTableName();
this.foreignColumnName = prototype.getForeignColumnName();
this.foreignTable = new AtomicReference<>();
this.foreignColumn = new AtomicReference<>();
this.column = new AtomicReference<>();
}
@Override
public String getId() {
return id;
}
@Override
public String getName() {
return name;
}
@Override
public int getOrdinalPosition() {
return ordinalPosition;
}
@Override
public String getForeignColumnName() {
return foreignColumnName;
}
@Override
public String getForeignTableName() {
return foreignTableName;
}
@Override
public Optional<ImmutableColumn> findForeignColumn() {
if (foreignColumn.get() == null) {
foreignColumn.set(ForeignKeyColumn.super.findForeignColumn().map(ImmutableColumn.class::cast).orElse(null));
}
return Optional.ofNullable(foreignColumn.get());
}
@Override
public Optional<ImmutableTable> findForeignTable() {<FILL_FUNCTION_BODY>}
@Override
public Optional<ImmutableColumn> findColumn() {
if (column.get() == null) {
column.set(ForeignKeyColumn.super.findColumn()
.map(ImmutableColumn.class::cast).orElse(null));
}
return Optional.ofNullable(column.get());
}
@Override
public Optional<ForeignKey> getParent() {
return super.getParent().map(ForeignKey.class::cast);
}
@Override
public String toString() {
return toStringHelper(this);
}
}
|
if (foreignTable.get() == null) {
foreignTable.set(ForeignKeyColumn.super.findForeignTable().map(ImmutableTable.class::cast).orElse(null));
}
return Optional.ofNullable(foreignTable.get());
| 711
| 69
| 780
|
<methods>public Stream<T> children(java.lang.String, BiFunction<P,Map<java.lang.String,java.lang.Object>,T>) ,public final Map<java.lang.String,java.lang.Object> getData() ,public final void put(java.lang.String, java.lang.Object) ,public java.lang.String toString() ,public static com.speedment.runtime.config.internal.immutable.ImmutableDocument wrap(com.speedment.runtime.config.Document) <variables>private final non-sealed Map<java.lang.String,List<com.speedment.runtime.config.Document>> children
|
speedment_speedment
|
speedment/runtime-parent/runtime-config/src/main/java/com/speedment/runtime/config/internal/immutable/ImmutableIndexColumn.java
|
ImmutableIndexColumn
|
findColumn
|
class ImmutableIndexColumn extends ImmutableDocument implements IndexColumn {
private final String id;
private final String name;
private final int ordinalPosition;
private final OrderType orderType;
private final AtomicReference<ImmutableColumn> column;
ImmutableIndexColumn(ImmutableIndex parent, Map<String, Object> ic) {
super(parent, ic);
final IndexColumn prototype = new IndexColumnImpl(parent, ic);
this.id = prototype.getId();
this.name = prototype.getName();
this.ordinalPosition = prototype.getOrdinalPosition();
this.orderType = prototype.getOrderType();
this.column = new AtomicReference<>();
}
@Override
public String getId() { return id; }
@Override
public String getName() { return name; }
@Override
public int getOrdinalPosition() {
return ordinalPosition;
}
@Override
public OrderType getOrderType() {
return orderType;
}
@Override
public Optional<ImmutableColumn> findColumn() {<FILL_FUNCTION_BODY>}
@Override
public Optional<Index> getParent() {
return super.getParent().map(Index.class::cast);
}
@Override
public String toString() {
return toStringHelper(this);
}
}
|
if (column.get() == null) {
column.set(IndexColumn.super.findColumn().map(ImmutableColumn.class::cast).orElse(null));
}
return Optional.ofNullable(column.get());
| 356
| 60
| 416
|
<methods>public Stream<T> children(java.lang.String, BiFunction<P,Map<java.lang.String,java.lang.Object>,T>) ,public final Map<java.lang.String,java.lang.Object> getData() ,public final void put(java.lang.String, java.lang.Object) ,public java.lang.String toString() ,public static com.speedment.runtime.config.internal.immutable.ImmutableDocument wrap(com.speedment.runtime.config.Document) <variables>private final non-sealed Map<java.lang.String,List<com.speedment.runtime.config.Document>> children
|
speedment_speedment
|
speedment/runtime-parent/runtime-config/src/main/java/com/speedment/runtime/config/internal/immutable/ImmutablePrimaryKeyColumn.java
|
ImmutablePrimaryKeyColumn
|
findColumn
|
class ImmutablePrimaryKeyColumn extends ImmutableDocument implements PrimaryKeyColumn {
private final String id;
private final String name;
private final int ordinalPosition;
private final AtomicReference<ImmutableColumn> column;
ImmutablePrimaryKeyColumn(ImmutableTable parent, Map<String, Object> pkc) {
super(parent, pkc);
final PrimaryKeyColumn prototype = new PrimaryKeyColumnImpl(parent, pkc);
this.id = prototype.getId();
this.name = prototype.getName();
this.ordinalPosition = prototype.getOrdinalPosition();
this.column = new AtomicReference<>();
}
@Override
public Optional<Table> getParent() {
return super.getParent().map(Table.class::cast);
}
@Override
public String getId() {
return id;
}
@Override
public String getName() {
return name;
}
@Override
public int getOrdinalPosition() {
return ordinalPosition;
}
@Override
public Optional<ImmutableColumn> findColumn() {<FILL_FUNCTION_BODY>}
@Override
public String toString() {
return toStringHelper(this);
}
}
|
if (column.get() == null) {
column.set(PrimaryKeyColumn.super.findColumn().map(ImmutableColumn.class::cast).orElse(null));
}
return Optional.ofNullable(column.get());
| 331
| 61
| 392
|
<methods>public Stream<T> children(java.lang.String, BiFunction<P,Map<java.lang.String,java.lang.Object>,T>) ,public final Map<java.lang.String,java.lang.Object> getData() ,public final void put(java.lang.String, java.lang.Object) ,public java.lang.String toString() ,public static com.speedment.runtime.config.internal.immutable.ImmutableDocument wrap(com.speedment.runtime.config.Document) <variables>private final non-sealed Map<java.lang.String,List<com.speedment.runtime.config.Document>> children
|
speedment_speedment
|
speedment/runtime-parent/runtime-config/src/main/java/com/speedment/runtime/config/internal/immutable/ImmutableProject.java
|
ImmutableProject
|
findTableByName
|
class ImmutableProject extends ImmutableDocument implements Project {
private final boolean enabled;
private final String id;
private final String name;
private final String companyName;
private final String packageName;
private final String packageLocation;
private final Path configPath;
private final List<Dbms> dbmses;
private final Map<String, ImmutableTable> tablesByName;
public ImmutableProject(Map<String, Object> project) {
super(project);
final Project prototype = Project.create(project);
this.enabled = prototype.isEnabled();
this.id = prototype.getId();
this.name = prototype.getName();
this.companyName = prototype.getCompanyName();
this.packageName = prototype.getPackageName().orElse(null);
this.packageLocation = prototype.getPackageLocation();
this.configPath = prototype.getConfigPath().orElse(null);
this.dbmses = unmodifiableList(super.children(DBMSES, ImmutableDbms::new).collect(toList()));
this.tablesByName = DocumentDbUtil.traverseOver(this, ImmutableTable.class)
.collect(toMap(
table -> DocumentUtil.relativeName(table, Dbms.class, DATABASE_NAME),
Function.identity()
));
}
@Override
public boolean isEnabled() {
return enabled;
}
@Override
public String getId() {
return id;
}
@Override
public String getName() {
return name;
}
@Override
public String getCompanyName() {
return companyName;
}
@Override
public Optional<String> getPackageName() {
return Optional.ofNullable(packageName);
}
@Override
public String getPackageLocation() {
return packageLocation;
}
@Override
public Optional<Path> getConfigPath() {
return Optional.ofNullable(configPath);
}
@Override
public Stream<Dbms> dbmses() {
return dbmses.stream();
}
@Override
public ImmutableTable findTableByName(String fullName) {<FILL_FUNCTION_BODY>}
}
|
final ImmutableTable table = tablesByName.get(fullName);
if (table == null) {
throw new SpeedmentConfigException(
"Unable to find table '" +
fullName +
"' in immutable config model."
);
}
return table;
| 576
| 77
| 653
|
<methods>public Stream<T> children(java.lang.String, BiFunction<P,Map<java.lang.String,java.lang.Object>,T>) ,public final Map<java.lang.String,java.lang.Object> getData() ,public final void put(java.lang.String, java.lang.Object) ,public java.lang.String toString() ,public static com.speedment.runtime.config.internal.immutable.ImmutableDocument wrap(com.speedment.runtime.config.Document) <variables>private final non-sealed Map<java.lang.String,List<com.speedment.runtime.config.Document>> children
|
speedment_speedment
|
speedment/runtime-parent/runtime-config/src/main/java/com/speedment/runtime/config/provider/BaseDocument.java
|
BaseDocument
|
getAsLong
|
class BaseDocument implements Document {
private final Document parent; // Nullable
private final Map<String, Object> config;
public BaseDocument(Document parent, Map<String, Object> data) {
this.parent = parent;
this.config = requireNonNull(data);
}
@Override
public Optional<? extends Document> getParent() {
return Optional.ofNullable(parent);
}
@Override
public Map<String, Object> getData() {
return config;
}
@Override
public Optional<Object> get(String key) {
return Optional.ofNullable(config.get(key));
}
@Override
public OptionalBoolean getAsBoolean(String key) {
return OptionalBoolean.ofNullable((Boolean) config.get(key));
}
@Override
public OptionalLong getAsLong(String key) {<FILL_FUNCTION_BODY>}
@Override
public OptionalDouble getAsDouble(String key) {
final Number value = (Number) config.get(key);
return value == null
? OptionalDouble.empty()
: OptionalDouble.of(value.doubleValue());
}
@Override
public OptionalInt getAsInt(String key) {
final Number value = (Number) config.get(key);
return value == null
? OptionalInt.empty()
: OptionalInt.of(value.intValue());
}
@Override
public Optional<String> getAsString(String key) {
return get(key).map(String.class::cast);
}
@Override
public void put(String key, Object value) {
requireNonNull(value);
config.put(key, value);
}
@Override
public Stream<Document> children() {
return childrenOf(this, BaseDocument::new);
}
}
|
final Number value = (Number) config.get(key);
return value == null
? OptionalLong.empty()
: OptionalLong.of(value.longValue());
| 475
| 47
| 522
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-config/src/main/java/com/speedment/runtime/config/util/ClassUtil.java
|
ClassUtil
|
classFromString
|
class ClassUtil {
/**
* Returns the full name of the specified type (including the array brackets
* if it is an array class).
*
* @param clazz class
* @return the absolute class name
*/
public static String classToString(Class<?> clazz) {
requireNonNull(clazz, "Class is null.");
if (clazz.isArray()) {
final Class<?> original = clazz.getComponentType();
return classToString(original) + "[]";
} else {
return clazz.getName();
}
}
/**
* Attempts to find the specified class using the default class loader. The
* class name may contain square brackets to indicate an array class. If the
* class can't be found, an {@link ClassNotFoundException} is thrown.
*
* @param className the full class name
* @return the class with that name
*
* @throws ClassNotFoundException if the class name could not be found
*/
public static Class<?> classFromString(String className) throws ClassNotFoundException {
return classFromString(className, null);
}
/**
* Attempts to find the specified class using the specified
* {@code classLoader}. If the class loader is {@code null}, then the
* default class loader is used. The class name may contain square brackets
* to indicate an array class. If the class can't be found, an
* {@link ClassNotFoundException} is thrown.
*
* @param className the full class name
* @param classLoader the class loader to use (or {@code null})
* @return the class with that name
*
* @throws ClassNotFoundException if the class name could not be found
*/
public static Class<?> classFromString(String className, ClassLoader classLoader) throws ClassNotFoundException {<FILL_FUNCTION_BODY>}
/**
* Utility classes should not be instantiated.
*/
private ClassUtil() {}
}
|
String inner = className;
int dimensions = 0;
while (inner.endsWith("[]")) {
inner = inner.substring(0, inner.length() - 2);
dimensions++;
}
final Class<?> innerClass;
switch (inner) {
case "byte": innerClass = byte.class; break;
case "short": innerClass = short.class; break;
case "int": innerClass = int.class; break;
case "long": innerClass = long.class; break;
case "float": innerClass = float.class; break;
case "double": innerClass = double.class; break;
case "boolean": innerClass = boolean.class; break;
case "char": innerClass = char.class; break;
default: if (classLoader == null) {
innerClass = Class.forName(inner);
} else {
innerClass = classLoader.loadClass(inner);
}
}
if (dimensions == 0) {
return innerClass;
} else {
return Array.newInstance(innerClass, dimensions).getClass();
}
| 507
| 291
| 798
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-config/src/main/java/com/speedment/runtime/config/util/DocumentTranscoder.java
|
DocumentTranscoder
|
load
|
class DocumentTranscoder {
private DocumentTranscoder() {}
/**
* The element name of the root node in the JSON configuration file. Every
* setting should be located in this element.
*/
public static final String ROOT = "config";
/**
* A functional interface describing a method that encodes a map of
* key-value pairs into a JSON String.
*/
@FunctionalInterface
public interface Encoder {
/**
* Encodes the specified map into a JSON string.
*
* @param map the map to encode
* @return the resulting JSON string
*/
String encode(Map<String, Object> map);
}
/**
* A functional interface describing a method that decodes a JSON String
* into a map of key-value pairs.
*/
@FunctionalInterface
public interface Decoder {
/**
* Decodes the specified JSON string into a map.
*
* @param text the JSON string to decode
* @return the resulting java map
*/
Map<String, Object> decode(String text);
}
/**
* Returns a JSON representation of the specified project node.
*
* @param project the project
* @param encoder the encoder to use
* @return the JSON representation
*
* @throws SpeedmentConfigException if the input object is not valid
*/
public static String save(Project project, Encoder encoder) {
if (project == null) {
return "null";
} else {
try {
final Map<String, Object> root = new LinkedHashMap<>();
root.put(ROOT, project.getData());
return encoder.encode(root);
} catch (final IllegalArgumentException ex) {
throw new SpeedmentConfigException(ex);
}
}
}
/**
* Saves the project in a UTF-8 encoded file.
*
* @param project to save
* @param encoder the encoder to use
* @param location for the UTF-8 encoded file
*
* @throws SpeedmentConfigException if the file could not be saved
*/
public static void save(Project project, Path location, Encoder encoder) {
try {
Files.write(location, save(project, encoder)
.getBytes(StandardCharsets.UTF_8));
} catch (final IOException ex) {
throw new SpeedmentConfigException(
"Could not save json-file to path '" + location + "'.", ex
);
}
}
/**
* Loads a new {@link Project} from the specified JSON string.
*
* @param json the input json
* @param decoder the decoder to use
* @return the parsed project
*
* @throws SpeedmentConfigException if the file couldn't be loaded
*/
public static Project load(String json, Decoder decoder) {<FILL_FUNCTION_BODY>}
/**
* Loads a project from a UTF-8 encoded file.
*
* @param location for the UTF-8 encoded file
* @param decoder the decoder to use
* @return that was loaded
*
* @throws SpeedmentConfigException if the file could not be loaded
*/
public static Project load(Path location, Decoder decoder) {
try {
final byte[] content = Files.readAllBytes(location);
return load(new String(content, StandardCharsets.UTF_8), decoder);
} catch (final IOException ex) {
throw new SpeedmentConfigException(
"Could not load json-file from path '" + location + "'.", ex
);
}
}
}
|
requireNonNull(json, "No json value specified.");
try {
final Map<String, Object> root = decoder.decode(json);
@SuppressWarnings("unchecked")
final Map<String, Object> data =
(Map<String, Object>) root.get(ROOT);
if (!data.containsKey(ProjectUtil.APP_ID)) {
data.put(ProjectUtil.APP_ID, UUID.randomUUID().toString());
}
return Project.create(data);
} catch (final Exception ex) {
throw new SpeedmentConfigException(ex);
}
| 958
| 161
| 1,119
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-config/src/main/java/com/speedment/runtime/config/util/TraitUtil.java
|
TraitUtil
|
viewOf
|
class TraitUtil {
/**
* Returns a view of the specified document that implements the specified
* trait. The returned document might or might not be the same instance as
* was inputted to this method. If not, the instance will be initialized
* using the specified constructor.
*
* @param <TRAIT> the trait class
* @param document the document to create a view of
* @param trait the trait type
* @param constructor constructor to use for documents that lack the trait
* @return the view of the trait
*/
public static <TRAIT extends Document> TRAIT viewOf(
Document document,
Class<TRAIT> trait,
TraitViewConstructor<? extends TRAIT> constructor) {<FILL_FUNCTION_BODY>}
/**
* A functional interface describing the constructor for a class that
* implements a specific trait.
*
* @param <TRAIT> the trait to construct an implementation of
*/
@FunctionalInterface
public interface TraitViewConstructor<TRAIT> {
TRAIT create(Document parent, Map<String, Object> data, Class<? extends Document> mainInterface);
}
/**
* Utility classes should not be instantiated.
*/
private TraitUtil() {
throw new UnsupportedOperationException();
}
}
|
if (trait.isInstance(document)) {
return trait.cast(document);
} else {
final Class<? extends Document> mainInterface;
if (document instanceof HasMainInterface) {
mainInterface = ((HasMainInterface) document).mainInterface();
} else {
mainInterface = trait;
}
return constructor.create(
document.getParent().orElse(null),
document.getData(),
mainInterface
);
}
| 350
| 131
| 481
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-connector-parent/postgres/src/main/java/com/speedment/runtime/connector/postgres/internal/PostgresDbmsMetadataHandler.java
|
PostgresDbmsMetadataHandler
|
stringRule
|
class PostgresDbmsMetadataHandler extends AbstractDbmsMetadataHandler {
PostgresDbmsMetadataHandler(
final ConnectionPoolComponent connectionPoolComponent,
final DbmsHandlerComponent dbmsHandlerComponent,
final ProjectComponent projectComponent
) {
super(connectionPoolComponent, dbmsHandlerComponent, projectComponent);
}
@Override
protected JavaTypeMap newJavaTypeMap() {
final JavaTypeMap javaTypeMap = super.newJavaTypeMap();
javaTypeMap.put("bytea", Blob.class);
// https://www.postgresql.org/docs/9.2/static/infoschema-datatypes.html
javaTypeMap.put("cardinal_number", Integer.class);
javaTypeMap.put("character_data", String.class);
javaTypeMap.put("sql_identifier", String.class);
javaTypeMap.put("time_stamp", Timestamp.class);
javaTypeMap.put("yes_or_no", String.class);
javaTypeMap.put("json", String.class);
javaTypeMap.put("jsonb", String.class);
javaTypeMap.addRule(bitRule());
javaTypeMap.addRule(yearRule());
javaTypeMap.addRule(stringRule("_text", 2003));
javaTypeMap.addRule(stringRule("tsvector", 1111));
return javaTypeMap;
}
private JavaTypeMap.Rule stringRule(String text, int i) {<FILL_FUNCTION_BODY>}
private JavaTypeMap.Rule yearRule() {
return (sqlTypeMapping, md) -> {
if ("year".equalsIgnoreCase(md.getTypeName()) && md.getDataType() == 2001) {
return Optional.of(Integer.class);
} else return Optional.empty();
};
}
private JavaTypeMap.Rule bitRule() {
return (sqlTypeMapping, md) -> {
// Map a BIT(1) to boolean
if ("BIT".equalsIgnoreCase(md.getTypeName()) && md.getColumnSize() == 1) {
return Optional.of(Boolean.class);
} else return Optional.empty();
};
}
@Override
protected void setAutoIncrement(Column column, ColumnMetaData md) throws SQLException {
super.setAutoIncrement(column, md);
final String defaultValue = md.getColumnDef();
if (defaultValue != null && defaultValue.startsWith("nextval(")) {
column.mutator().setAutoIncrement(true);
}
}
}
|
return (sqlTypeMapping, md) -> {
if (text.equalsIgnoreCase(md.getTypeName()) && md.getDataType() == i) {
return Optional.of(String.class);
} else return Optional.empty();
};
| 661
| 66
| 727
|
<methods>public java.lang.String getDbmsInfoString(com.speedment.runtime.config.Dbms) throws java.sql.SQLException,public CompletableFuture<com.speedment.runtime.config.Project> readSchemaMetadata(com.speedment.runtime.config.Dbms, com.speedment.runtime.core.util.ProgressMeasure, Predicate<java.lang.String>) <variables>private static final Class<?> DEFAULT_MAPPING,public static final boolean EXTRA_INFO,private static final com.speedment.common.logger.Logger LOGGER,public static final boolean SHOW_METADATA,private final non-sealed com.speedment.runtime.core.component.connectionpool.ConnectionPoolComponent connectionPoolComponent,private final non-sealed com.speedment.runtime.core.component.DbmsHandlerComponent dbmsHandlerComponent,private final non-sealed com.speedment.runtime.core.db.JavaTypeMap javaTypeMap,private final non-sealed com.speedment.runtime.core.component.ProjectComponent projectComponent,private final non-sealed Map<Class<? extends com.speedment.runtime.config.Document>,java.util.concurrent.atomic.AtomicLong> timers
|
speedment_speedment
|
speedment/runtime-parent/runtime-connector-parent/postgres/src/main/java/com/speedment/runtime/connector/postgres/internal/PostgresDbmsOperationHandler.java
|
PostgresDbmsOperationHandler
|
generatedKeysHandler
|
class PostgresDbmsOperationHandler implements DbmsOperationHandler {
private static final int FETCH_SIZE = 4096;
// Five elements - list is surely more efficient than a hash set
private static final List<Integer> LONG_GETTABLE_TYPES = Arrays.asList(
Types.TINYINT,
Types.SMALLINT,
Types.INTEGER,
Types.BIGINT,
Types.NUMERIC
);
private final DbmsOperationHandler inner;
PostgresDbmsOperationHandler(
final ConnectionPoolComponent connectionPoolComponent,
final TransactionComponent transactionComponent
) {
inner = DbmsOperationalHandlerBuilder.create(connectionPoolComponent, transactionComponent)
.withGeneratedKeysHandler(PostgresDbmsOperationHandler::generatedKeysHandler)
.withConfigureSelectPreparedStatement(ps -> ps.setFetchSize(FETCH_SIZE))
.withConfigureSelectResultSet(rs -> rs.setFetchSize(FETCH_SIZE))
.build();
}
@ExecuteBefore(State.STOPPED)
@Override
public void close() {
inner.close();
}
@Override
public void configureSelect(PreparedStatement statement) throws SQLException {
inner.configureSelect(statement);
}
@Override
public void configureSelect(ResultSet resultSet) throws SQLException {
inner.configureSelect(resultSet);
}
@Override
public Clob createClob(Dbms dbms) throws SQLException {
return inner.createClob(dbms);
}
@Override
public Blob createBlob(Dbms dbms) throws SQLException {
return inner.createBlob(dbms);
}
@Override
public NClob createNClob(Dbms dbms) throws SQLException {
return inner.createNClob(dbms);
}
@Override
public SQLXML createSQLXML(Dbms dbms) throws SQLException {
return inner.createSQLXML(dbms);
}
@Override
public Array createArray(Dbms dbms, String typeName, Object[] elements) throws SQLException {
return inner.createArray(dbms, typeName, elements);
}
@Override
public Struct createStruct(Dbms dbms, String typeName, Object[] attributes) throws SQLException {
return inner.createStruct(dbms, typeName, attributes);
}
@Override
public <T> Stream<T> executeQuery(Dbms dbms, String sql, SqlFunction<ResultSet, T> rsMapper) {
return inner.executeQuery(dbms, sql, rsMapper);
}
@Override
public <T> Stream<T> executeQuery(Dbms dbms, String sql, List<?> values, SqlFunction<ResultSet, T> rsMapper) {
return inner.executeQuery(dbms, sql, values, rsMapper);
}
@Override
public <T> AsynchronousQueryResult<T> executeQueryAsync(Dbms dbms, String sql, List<?> values, SqlFunction<ResultSet, T> rsMapper, ParallelStrategy parallelStrategy) {
return inner.executeQueryAsync(dbms, sql, values, rsMapper, parallelStrategy);
}
@Override
public <ENTITY> void executeInsert(Dbms dbms, String sql, List<?> values, Collection<Field<ENTITY>> generatedKeyFields, Consumer<List<Long>> generatedKeyConsumer) throws SQLException {
inner.executeInsert(dbms, sql, values, generatedKeyFields, generatedKeyConsumer);
}
@Override
public void executeUpdate(Dbms dbms, String sql, List<?> values) throws SQLException {
inner.executeUpdate(dbms, sql, values);
}
@Override
public void executeDelete(Dbms dbms, String sql, List<?> values) throws SQLException {
inner.executeDelete(dbms, sql, values);
}
private static void generatedKeysHandler(PreparedStatement ps, LongConsumer longConsumer) throws SQLException {<FILL_FUNCTION_BODY>}
}
|
/*
* There does not seem to be any way to find the generated keys from a Postgres JDBC driver
* since getGeneratedKeys() returns the whole set of columns. This causes
* bug #293 "The postgresql throws an exception when the PRIMARY KEY is not type long."
*
* See http://stackoverflow.com/questions/19766816/postgresql-jdbc-getgeneratedkeys-returns-all-columns
*
* Below we instead handle auto generated fields that can be retrieved as Long. This fix clearly only
* works for generated fields that are also auto generated.
*/
try (final ResultSet generatedKeys = ps.getGeneratedKeys()) {
while (generatedKeys.next()) {
final int columnType = generatedKeys.getMetaData().getColumnType(1);
if (generatedKeys.getMetaData().isAutoIncrement(1) && LONG_GETTABLE_TYPES.contains(columnType)) {
longConsumer.accept(generatedKeys.getLong(1));
}
}
}
| 1,042
| 261
| 1,303
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-connector-parent/sqlite/src/main/java/com/speedment/runtime/connector/sqlite/internal/SqliteFieldPredicateView.java
|
SqliteFieldPredicateView
|
startsWithIgnoreCaseHelper
|
class SqliteFieldPredicateView extends AbstractFieldPredicateView {
@Override
protected SqlPredicateFragment equalHelper(String cn, Object argument) {
return of("(" + cn + " = ?)").add(argument);
}
@Override
protected SqlPredicateFragment notEqualHelper(String cn, Object argument) {
return of("(" + cn + " != ?)").add(argument);
}
@Override
protected SqlPredicateFragment equalIgnoreCaseHelper(String cn, FieldPredicate<?> model, boolean negated) {
return of("(" + cn + " COLLATE NOCASE " + (negated ? "!= ?)" : "= ?)"))
.add(getFirstOperandAsRaw(model));
}
@Override
protected SqlPredicateFragment startsWithHelper(String cn, FieldPredicate<?> model, boolean negated) {
return of("(" + cn + " GLOB (? || \"*\"))", negated)
.add(getFirstOperandAsRaw(model));
}
@Override
protected SqlPredicateFragment startsWithIgnoreCaseHelper(String cn, FieldPredicate<?> model, boolean negated) {<FILL_FUNCTION_BODY>}
@Override
protected SqlPredicateFragment endsWithHelper(String cn, FieldPredicate<?> model, boolean negated) {
return of("(" + cn + " GLOB (\"*\" || ?))", negated)
.add(getFirstOperandAsRaw(model));
}
@Override
protected SqlPredicateFragment endsWithIgnoreCaseHelper(String cn, FieldPredicate<?> model, boolean negated) {
return of("(" + cn + " COLLATE NOCASE LIKE (\"%\" || ?) ESCAPE \"_\")", negated)
.add(getFirstOperandAsRaw(model));
}
@Override
protected SqlPredicateFragment containsHelper(String cn, FieldPredicate<?> model, boolean negated) {
return of("(" + cn + " GLOB (\"*\" || ? || \"*\"))", negated)
.add(getFirstOperandAsRaw(model));
}
@Override
protected SqlPredicateFragment containsIgnoreCaseHelper(String cn, FieldPredicate<?> model, boolean negated) {
return of("(" + cn + " COLLATE NOCASE LIKE (\"%\" || ? || \"%\") ESCAPE \"_\")", negated)
.add(getFirstOperandAsRaw(model));
}
}
|
return of("(" + cn + " COLLATE NOCASE LIKE (? || \"%\") ESCAPE \"_\")", negated)
.add(getFirstOperandAsRaw(model));
| 646
| 53
| 699
|
<methods>public non-sealed void <init>() ,public com.speedment.runtime.core.db.SqlPredicateFragment transform(Function<Field<ENTITY>,java.lang.String>, Function<Field<ENTITY>,Class<?>>, FieldPredicate<ENTITY>) <variables>private static final java.lang.String GREATER_OR_EQUAL_WILDCARD,private static final java.lang.String GREATER_THAN_WILDCARD,private static final java.lang.String LESS_OR_EQUAL_WILDCARD,private static final java.lang.String LESS_THAN_WILDCARD,private static final java.lang.String NOT
|
speedment_speedment
|
speedment/runtime-parent/runtime-connector-parent/sqlite/src/main/java/com/speedment/runtime/connector/sqlite/internal/types/SqlTypeMappingHelperImpl.java
|
SqlTypeMappingHelperImpl
|
readTypeMapFromDB
|
class SqlTypeMappingHelperImpl implements SqlTypeMappingHelper {
private final ConnectionPoolComponent connectionPool;
private final DbmsHandlerComponent dbmsHandler;
private final JavaTypeMap javaTypeMap;
SqlTypeMappingHelperImpl(
final ConnectionPoolComponent connectionPool,
final DbmsHandlerComponent dbmsHandler,
final JavaTypeMap javaTypeMap
) {
this.connectionPool = requireNonNull(connectionPool);
this.dbmsHandler = requireNonNull(dbmsHandler);
this.javaTypeMap = requireNonNull(javaTypeMap);
}
@Override
public CompletableFuture<Map<String, Class<?>>> loadFor(Dbms dbms) {
final DbmsType dbmsType = dbmsTypeOf(dbmsHandler, dbms);
final Set<TypeInfoMetaData> preSet = dbmsType.getDataTypes();
return supplyAsync(() -> {
final Map<String, Class<?>> sqlTypeMapping;
try {
sqlTypeMapping = !preSet.isEmpty()
? readTypeMapFromSet(preSet)
: readTypeMapFromDB(dbms);
} catch (final SQLException ex) {
throw new SpeedmentException(
"Error loading type map from database.", ex
);
}
return sqlTypeMapping;
});
}
@Override
public Optional<Class<?>> findFor(Map<String, Class<?>> loaded, ColumnMetaData metaData) {
return Optional.ofNullable(javaTypeMap.findJdbcType(loaded, metaData));
}
private Map<String, Class<?>> readTypeMapFromSet(Set<TypeInfoMetaData> typeInfos) {
return typeMapFromTypeInfo(new ArrayList<>(typeInfos));
}
private Map<String, Class<?>> readTypeMapFromDB(Dbms dbms) throws SQLException {<FILL_FUNCTION_BODY>}
private Map<String, Class<?>> typeMapFromTypeInfo(List<TypeInfoMetaData> typeInfoMetaDataList) {
requireNonNull(typeInfoMetaDataList);
final Map<String, Class<?>> result = newCaseInsensitiveMap();
// First, put the java.sql.Types mapping for all types
typeInfoMetaDataList.forEach(ti -> {
final Optional<String> javaSqlTypeName = ti.javaSqlTypeName();
javaSqlTypeName.ifPresent(tn -> {
final Class<?> mappedClass = javaTypeMap.get(tn);
if (mappedClass != null) {
result.put(tn, mappedClass);
}
});
});
// Then, put the typeInfo sqlName (That may be more specific) for all types
typeInfoMetaDataList.forEach(ti -> {
final String key = ti.getSqlTypeName();
final Class<?> mappedClass = javaTypeMap.get(key);
if (mappedClass != null) {
result.put(key, mappedClass);
} else {
final Optional<String> javaSqlTypeName = ti.javaSqlTypeName();
javaSqlTypeName.ifPresent(ltn -> {
final Class<?> lookupMappedClass = javaTypeMap.get(ltn);
if (lookupMappedClass != null) {
result.put(key, lookupMappedClass);
}
});
}
});
return result;
}
}
|
requireNonNull(dbms);
final List<TypeInfoMetaData> typeInfoMetaDataList = new ArrayList<>();
try (final Connection connection = connectionPool.getConnection(dbms)) {
try (final ResultSet rs = connection.getMetaData().getTypeInfo()) {
while (rs.next()) {
final TypeInfoMetaData typeInfo = TypeInfoMetaData.of(rs);
typeInfoMetaDataList.add(typeInfo);
}
}
return typeMapFromTypeInfo(typeInfoMetaDataList);
}
| 857
| 137
| 994
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/abstracts/AbstractDatabaseNamingConvention.java
|
AbstractDatabaseNamingConvention
|
escapeIfQuote
|
class AbstractDatabaseNamingConvention implements DatabaseNamingConvention {
private static final String DEFAULT_DELIMITER = ".";
private static final String DEFAULT_QUOTE = "'";
@Override
public String fullNameOf(String schemaName, String tableName, String columnName) {
return fullNameOf(schemaName, tableName) + DEFAULT_DELIMITER
+ encloseField(columnName);
}
@Override
public String fullNameOf(String schemaName, String tableName) {
return encloseField(schemaName) + DEFAULT_DELIMITER
+ encloseField(tableName);
}
@Override
public String quoteField(String field) {
return getFieldQuoteStart() + field + getFieldQuoteEnd();
}
@Override
public String encloseField(String field) {
return getFieldEncloserStart() + field + getFieldEncloserEnd();
}
/**
* Returns the non-null field quote start string. The field quote start
* string precedes a database value used in among other things comparisons.
*
* @return the non-null field quote start string
* @see #getFieldQuoteEnd()
*/
protected String getFieldQuoteStart() {
return DEFAULT_QUOTE;
}
/**
* Returns the non-null field quote end string. The field quote end string
* precedes a database value used in among other things comparisons.
*
* @return the non-null field quote end string
* @see #getFieldQuoteEnd()
*/
protected String getFieldQuoteEnd() {
return DEFAULT_QUOTE;
}
/**
* Returns the non-null field encloser start string. The field encloser
* start string precedes a database entity name like a table or schema name
* when quoted. Quoted names are used to avoid that entity names collide
* with reserved keywords like "key" or "user". So a table named "user" in
* the "key" schema can be quoted to "key"."user". Examples of values are
* '`' for MySQL or '"' for Oracle.
*
* @return the non-null field encloser start string
*
* @see #getFieldEncloserStart(boolean)
* @see #getFieldEncloserEnd()
* @see #getFieldEncloserEnd(boolean)
*/
protected abstract String getFieldEncloserStart();
/**
* Returns the non-null field encloser start string. The method parameter
* denotes if the field encloser is placed within quotes or not. For example
* for Oracle, since the field encloser is the '"' character itself, it
* needs to be escaped if within quotes.
*
* @param isWithinQuotes if the field encloser is within quotes
* @return Returns the non-null field encloser start string
*
* @see #getFieldEncloserStart()
*/
protected String getFieldEncloserStart(boolean isWithinQuotes) {
return escapeIfQuote(getFieldEncloserStart(), isWithinQuotes);
}
/**
* Returns the non-null field encloser end string. The field encloser end
* string follows a database entity name like a table or schema name when
* quoted. Quoted names are used to avoid that entity names collide with
* reserved keywords like "key" or "user". So a table named "user" in the
* "key" schema can be quoted to "key"."user". Examples of values are '`'
* for MySQL or '"' for Oracle.
*
* @return the non-null field encloser end string
*
* @see #getFieldEncloserStart(boolean)
* @see #getFieldEncloserEnd()
* @see #getFieldEncloserEnd(boolean)
*/
protected abstract String getFieldEncloserEnd();
/**
* Returns the non-null field encloser end string. The method parameter
* denotes if the field encloser is placed within quotes or not. For example
* for Oracle, since the field encloser is the '"' character itself, it
* needs to be escaped if within quotes.
*
* @param isWithinQuotes if the field encloser is within quotes
* @return Returns the non-null field encloser start string
*
* @see #getFieldEncloserEnd()
*/
protected String getFieldEncloserEnd(boolean isWithinQuotes) {
return escapeIfQuote(getFieldEncloserEnd(), isWithinQuotes);
}
private String escapeIfQuote(String item, boolean isWithinQuotes) {<FILL_FUNCTION_BODY>}
}
|
if (isWithinQuotes && "\"".equals(item)) {
return "\\" + item;
} else {
return item;
}
| 1,189
| 43
| 1,232
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/component/ManagerComponentImpl.java
|
ManagerComponentImpl
|
managerOf
|
class ManagerComponentImpl implements ManagerComponent {
private final Map<Class<?>, Manager<?>> managersByEntity;
public ManagerComponentImpl() {
managersByEntity = new ConcurrentHashMap<>();
}
@Override
public <ENTITY> void put(Manager<ENTITY> manager) {
requireNonNull(manager);
managersByEntity.put(manager.getEntityClass(), manager);
}
@Override
@SuppressWarnings("unchecked")
public <E> Manager<E> managerOf(Class<E> entityClass) {<FILL_FUNCTION_BODY>}
@Override
public Stream<Manager<?>> stream() {
return managersByEntity.values().stream();
}
}
|
requireNonNull(entityClass);
@SuppressWarnings("unchecked")
final Manager<E> manager = (Manager<E>)
managersByEntity.get(entityClass);
if (manager == null) {
throw new SpeedmentException(
"No manager exists for " + entityClass
);
}
return manager;
| 187
| 98
| 285
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/component/PasswordComponentImpl.java
|
PasswordComponentImpl
|
get
|
class PasswordComponentImpl implements PasswordComponent {
private final Map<String, char[]> passwords;
public PasswordComponentImpl() {
this.passwords = new ConcurrentHashMap<>();
}
@Override
public void put(String dbmsName, char[] password) {
requireNonNull(dbmsName);
if (password == null) {
passwords.remove(dbmsName);
} else {
passwords.put(dbmsName, password);
}
}
@Override
public Optional<char[]> get(String dbmsName) {<FILL_FUNCTION_BODY>}
}
|
requireNonNull(dbmsName);
final char[] value = passwords.get(dbmsName);
if (value == null) {
return Optional.empty();
} else {
return Optional.of(value);
}
| 163
| 62
| 225
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/component/StatisticsReporterSchedulerComponentImpl.java
|
StatisticsReporterSchedulerComponentImpl
|
guardedCall
|
class StatisticsReporterSchedulerComponentImpl implements StatisticsReporterSchedulerComponent {
private static final Logger LOGGER = LoggerManager.getLogger(StatisticsReporterSchedulerComponentImpl.class);
private final AtomicBoolean outstanding;
private final boolean enabled;
private final ScheduledExecutorService scheduler;
public StatisticsReporterSchedulerComponentImpl(@Config(name = "statistics.scheduler.enabled", value = "true") final boolean enabled) {
this.enabled = enabled;
outstanding = new AtomicBoolean();
if (enabled) {
scheduler = Executors.newSingleThreadScheduledExecutor(r -> {
final Thread t = new Thread(r);
t.setDaemon(true);
return t;
}); // Make the threads daemon to allow speedment applications to exit via main method completion Fix #322
} else {
scheduler = null;
}
}
@ExecuteBefore(State.STARTED)
public void start(StatisticsReporterComponent src) {
if (enabled) {
scheduler.submit(src::reportStarted);
scheduler.scheduleAtFixedRate(() -> guardedCall(src::alive), 1, 1, TimeUnit.HOURS);
}
}
@ExecuteBefore(State.STOPPED)
public void stop(StatisticsReporterComponent src) {
if (enabled) {
scheduler.submit(src::reportStopped);
try {
scheduler.awaitTermination(2, TimeUnit.SECONDS);
} catch (InterruptedException ie) {
LOGGER.error("Unable to terminate " + StatisticsReporterSchedulerComponentImpl.class.getSimpleName());
Thread.currentThread().interrupt();
} finally {
scheduler.shutdownNow();
}
}
}
/**
* Method to guard from multiple invocations. Used to fix #708
* @param r runnable
*/
void guardedCall(Runnable r) {<FILL_FUNCTION_BODY>}
}
|
if (outstanding.compareAndSet(false,true)) {
try {
r.run();
} finally {
outstanding.set(false);
}
}
| 520
| 49
| 569
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/component/resultset/ResultSetMapperComponentImpl.java
|
ResultSetMapperComponentImpl
|
apply
|
class ResultSetMapperComponentImpl implements ResultSetMapperComponent {
private final Map<Class<?>, ResultSetMapping<?>> map;
private final Map<DbmsType, Map<Class<?>, ResultSetMapping<?>>> dbmsTypeMap;
public ResultSetMapperComponentImpl() {
map = newConcurrentMap();
dbmsTypeMap = newConcurrentMap();
StandardJavaTypeMapping.stream().forEach(this::put);
}
public ResultSetMapping<?> put(ResultSetMapping<?> item) {
requireNonNull(item);
return map.put(item.getJavaClass(), item);
}
public ResultSetMapping<?> put(DbmsType dbmsType, ResultSetMapping<?> item) {
requireNonNulls(dbmsType, item);
return dbmsTypeMap.computeIfAbsent(dbmsType, k -> new ConcurrentHashMap<>()).put(item.getJavaClass(), item);
}
@Override
public <T> ResultSetMapping<T> apply(DbmsType dbmsType, Class<T> javaClass) {<FILL_FUNCTION_BODY>}
@Override
public <T> ResultSetMapping<T> apply(Class<T> javaClass) {
requireNonNull(javaClass);
return getFromMapOrThrow(map, javaClass, javaClass::getName);
}
@SuppressWarnings("unchecked")
private <T> ResultSetMapping<T> getFromMapOrThrow(Map<Class<?>, ResultSetMapping<?>> map, Class<T> javaClass, Supplier<String> throwMessageSupplier) {
requireNonNulls(map, javaClass, throwMessageSupplier);
return Optional.ofNullable((ResultSetMapping<T>) map.get(javaClass))
.orElseThrow(() -> new NullPointerException("The " + ResultSetMapperComponent.class.getSimpleName() + " does not have a mapping for " + throwMessageSupplier.get()));
}
private <K, V> Map<K, V> newConcurrentMap() {
return new ConcurrentHashMap<>();
}
}
|
requireNonNulls(dbmsType, javaClass);
return getFromMapOrThrow(dbmsTypeMap.getOrDefault(dbmsType, map), javaClass, () -> dbmsType + ", " + javaClass.getName());
| 533
| 59
| 592
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/component/sql/MetricsImpl.java
|
MetricsImpl
|
equals
|
class MetricsImpl implements Metrics {
public static final Metrics EMPTY_INSTANCE = new MetricsImpl(0, 0, 0, 0, 0);
private final int pipelineReductions;
private final int sqlWhileCount;
private final int sqlOrderCount;
private final int sqlSkipCount;
private final int sqlLimitCount;
public MetricsImpl(
final int pipelineReductions,
final int sqlWhileCount,
final int sqlOrderCount,
final int sqlSkipCount,
final int sqlLimitCount
) {
this.pipelineReductions = requireNonNegative(pipelineReductions);
this.sqlWhileCount = requireNonNegative(sqlWhileCount);
this.sqlOrderCount = requireNonNegative(sqlOrderCount);
this.sqlSkipCount = requireNonNegative(sqlSkipCount);
this.sqlLimitCount = requireNonNegative(sqlLimitCount);
}
@Override
public int getPipelineReductions() {
return pipelineReductions;
}
@Override
public int getSqlWhileCount() {
return sqlWhileCount;
}
@Override
public int getSqlOrderCount() {
return sqlOrderCount;
}
@Override
public int getSqlSkipCount() {
return sqlSkipCount;
}
@Override
public int getSqlLimitCount() {
return sqlLimitCount;
}
@Override
public String toString() {
return String.format("Metrics {pipelineReductions = %d, sqlWhileCount = %d, sqlOrderCount = %d, sqlSkipCount = %d, sqlLimitCount = %d}",
getPipelineReductions(),
getSqlWhileCount(),
getSqlOrderCount(),
getSqlSkipCount(),
getSqlLimitCount()
);
}
@Override
public boolean equals(Object obj) {<FILL_FUNCTION_BODY>}
@Override
public int hashCode() {
int hash = 33;
hash += 33 * getPipelineReductions();
hash += 33 * getSqlWhileCount();
hash += 33 * getSqlOrderCount();
hash += 33 * getSqlSkipCount();
hash += 33 * getSqlLimitCount();
return hash;
}
}
|
if (obj == this) {
return true;
}
if (!(obj instanceof Metrics)) {
return false;
}
final Metrics that = (Metrics) obj;
return this.getPipelineReductions() == that.getPipelineReductions()
&& this.getSqlWhileCount() == that.getSqlWhileCount()
&& this.getSqlOrderCount() == that.getSqlOrderCount()
&& this.getSqlSkipCount() == that.getSqlSkipCount()
&& this.getSqlLimitCount() == that.getSqlLimitCount();
| 586
| 145
| 731
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/component/sql/SqlPersistenceComponentImpl.java
|
SqlPersistenceComponentImpl
|
persistenceProvider
|
class SqlPersistenceComponentImpl implements SqlPersistenceComponent {
private final ProjectComponent projectComponent;
private final DbmsHandlerComponent dbmsHandlerComponent;
private final ManagerComponent managerComponent;
private final ResultSetMapperComponent resultSetMapperComponent;
public SqlPersistenceComponentImpl(
final ProjectComponent projectComponent,
final DbmsHandlerComponent dbmsHandlerComponent,
final ManagerComponent managerComponent,
final ResultSetMapperComponent resultSetMapperComponent
) {
this.projectComponent = requireNonNull(projectComponent);
this.dbmsHandlerComponent = requireNonNull(dbmsHandlerComponent);
this.managerComponent = requireNonNull(managerComponent);
this.resultSetMapperComponent = requireNonNull(resultSetMapperComponent);
}
@Override
public <ENTITY> PersistenceProvider<ENTITY> persistenceProvider(PersistenceTableInfo<ENTITY> tableInfo) {<FILL_FUNCTION_BODY>}
}
|
return new SqlPersistenceProviderImpl<>(
tableInfo,
projectComponent,
dbmsHandlerComponent,
managerComponent,
resultSetMapperComponent
);
| 229
| 45
| 274
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/component/sql/SqlStreamOptimizerComponentImpl.java
|
SqlStreamOptimizerComponentImpl
|
get
|
class SqlStreamOptimizerComponentImpl implements SqlStreamOptimizerComponent {
private static final Logger LOGGER_STREAM_OPTIMIZER = LoggerManager.getLogger(ApplicationBuilder.LogType.STREAM_OPTIMIZER.getLoggerName());
private static final SqlStreamOptimizer<?> FALL_BACK = new FallbackStreamOptimizer<>();
private final List<SqlStreamOptimizer<?>> optimizers;
public SqlStreamOptimizerComponentImpl() {
this.optimizers = new CopyOnWriteArrayList<>();
install(new InitialFilterOptimizer<>());
install(new FilterSortedSkipOptimizer<>());
}
@Override
public <ENTITY> SqlStreamOptimizer<ENTITY> get(Pipeline initialPipeline, DbmsType dbmsType) {<FILL_FUNCTION_BODY>}
private static final Comparator<Metrics> METRICS_COMPARATOR
= comparingInt(Metrics::getPipelineReductions)
.thenComparing(comparingInt(Metrics::getSqlCount).reversed());
private <ENTITY> SqlStreamOptimizer<ENTITY> getHelper(Pipeline initialPipeline, DbmsType dbmsType) {
@SuppressWarnings("unchecked")
SqlStreamOptimizer<ENTITY> result = (SqlStreamOptimizer<ENTITY>) FALL_BACK;
if (initialPipeline.isEmpty()) {
return result;
}
Metrics metric = Metrics.empty();
for (int i = optimizers.size() - 1; i >= 0; i--) {
@SuppressWarnings("unchecked")
final SqlStreamOptimizer<ENTITY> candidate = (SqlStreamOptimizer<ENTITY>) optimizers.get(i);
final Metrics candidateMetric = candidate.metrics(initialPipeline, dbmsType);
if (DEBUG.isEqualOrHigherThan(LOGGER_STREAM_OPTIMIZER.getLevel())) {
LOGGER_STREAM_OPTIMIZER.debug("Candidate: %-30s : %s ", candidate.getClass().getSimpleName(), candidateMetric);
}
if (METRICS_COMPARATOR.compare(candidateMetric, metric) > 0) {
metric = candidateMetric;
result = candidate;
if (metric.getPipelineReductions() == Integer.MAX_VALUE) {
return result;
}
}
}
return result;
}
@Override
public <ENTITY> void install(SqlStreamOptimizer<ENTITY> sqlStreamOptimizer) {
requireNonNull(sqlStreamOptimizer);
optimizers.add(sqlStreamOptimizer);
}
@Override
public Stream<SqlStreamOptimizer<?>> stream() {
return optimizers.stream();
}
private static class FallbackStreamOptimizer<ENTITY> implements SqlStreamOptimizer<ENTITY> {
@Override
public <P extends Pipeline> Metrics metrics(P initialPipeline, DbmsType dbmsType) {
return Metrics.empty();
}
@Override
public <P extends Pipeline> P optimize(P initialPipeline, SqlStreamOptimizerInfo<ENTITY> info, AsynchronousQueryResult<ENTITY> query) {
return initialPipeline;
}
}
}
|
if (DEBUG.isEqualOrHigherThan(LOGGER_STREAM_OPTIMIZER.getLevel())) {
LOGGER_STREAM_OPTIMIZER.debug("Evaluating %s pipeline: %s", initialPipeline.isParallel() ? "parallel" : "sequential", initialPipeline.toString());
}
final SqlStreamOptimizer<ENTITY> result = getHelper(initialPipeline, dbmsType);
if (DEBUG.isEqualOrHigherThan(LOGGER_STREAM_OPTIMIZER.getLevel())) {
LOGGER_STREAM_OPTIMIZER.debug("Selected: %s", result.getClass().getSimpleName());
}
return result;
| 849
| 180
| 1,029
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/component/sql/SqlStreamSupplierComponentImpl.java
|
SqlStreamSupplierComponentImpl
|
startStreamSuppliers
|
class SqlStreamSupplierComponentImpl implements SqlStreamSupplierComponent {
private final Map<TableIdentifier<?>, SqlStreamSupplier<?>> supportMap;
private final boolean allowStreamIteratorAndSpliterator;
public SqlStreamSupplierComponentImpl(
@Config(name = "allowStreamIteratorAndSpliterator", value = "false") final boolean allowStreamIteratorAndSpliterator
) {
this.supportMap = new ConcurrentHashMap<>();
this.allowStreamIteratorAndSpliterator = allowStreamIteratorAndSpliterator;
}
@ExecuteBefore(STARTED)
@SuppressWarnings("unchecked")
public void startStreamSuppliers(
final Injector injector,
final ProjectComponent projectComponent,
final DbmsHandlerComponent dbmsHandlerComponent,
final ManagerComponent managerComponent,
final SqlStreamOptimizerComponent sqlStreamOptimizerComponent,
final SqlStreamTerminatorComponent sqlStreamTerminatorComponent
) {<FILL_FUNCTION_BODY>}
@Override
public <ENTITY> Stream<ENTITY> stream(TableIdentifier<ENTITY> tableIdentifier, ParallelStrategy parallelStrategy) {
final SqlStreamSupplier<ENTITY> supplier = getStreamSupplier(tableIdentifier);
return supplier.stream(parallelStrategy);
}
private <ENTITY> SqlStreamSupplier<ENTITY> getStreamSupplier(TableIdentifier<ENTITY> tableIdentifier) {
@SuppressWarnings("unchecked")
final SqlStreamSupplier<ENTITY> streamSupplier = (SqlStreamSupplier<ENTITY>) supportMap.get(tableIdentifier);
return requireNonNull(streamSupplier,
"No Sql Stream Supplier installed for table identifier "
+ tableIdentifier
);
}
}
|
// the trace component is optional
final SqlTraceComponent sqlTraceComponent = injector.get(SqlTraceComponent.class).orElse(null);
injector.stream(SqlAdapter.class)
.forEach(sa -> {
final SqlStreamSupplier<Object> supplier = new SqlStreamSupplierImpl<>(
(TableIdentifier<Object>) sa.identifier(),
(SqlFunction<ResultSet, Object>) sa.entityMapper(),
projectComponent,
dbmsHandlerComponent,
managerComponent,
sqlStreamOptimizerComponent,
sqlStreamTerminatorComponent,
sqlTraceComponent,
allowStreamIteratorAndSpliterator
);
supportMap.put(sa.identifier(), supplier);
});
| 432
| 179
| 611
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/component/sql/SqlStreamSupplierImpl.java
|
SqlStreamSupplierImpl
|
stream
|
class SqlStreamSupplierImpl<ENTITY> implements SqlStreamSupplier<ENTITY> {
private static final Logger LOGGER_SELECT = LoggerManager.getLogger(ApplicationBuilder.LogType.STREAM.getLoggerName()); // Hold an extra reference to this logger
private final SqlFunction<ResultSet, ENTITY> entityMapper;
private final Dbms dbms;
private final DbmsType dbmsType;
private final Map<ColumnIdentifier<ENTITY>, String> columnNameMap;
private final Map<ColumnIdentifier<ENTITY>, Class<?>> columnDatabaseTypeMap;
private final String sqlSelect;
private final String sqlSelectCount;
private final String sqlTableReference;
private final SqlStreamOptimizerComponent sqlStreamOptimizerComponent;
private final SqlStreamTerminatorComponent sqlStreamTerminatorComponent;
private final SqlTraceComponent sqlTraceComponent;
private final boolean allowIteratorAndSpliterator;
SqlStreamSupplierImpl(
final TableIdentifier<ENTITY> tableId,
final SqlFunction<ResultSet, ENTITY> entityMapper,
final ProjectComponent projectComponent,
final DbmsHandlerComponent dbmsHandlerComponent,
final ManagerComponent managerComponent,
final SqlStreamOptimizerComponent sqlStreamOptimizerComponent,
final SqlStreamTerminatorComponent sqlStreamTerminatorComponent,
final SqlTraceComponent sqlTraceComponent,
final boolean allowIteratorAndSpliterator
) {
requireNonNull(tableId);
requireNonNull(projectComponent);
requireNonNull(dbmsHandlerComponent);
requireNonNull(managerComponent);
this.entityMapper = requireNonNull(entityMapper);
this.sqlStreamOptimizerComponent = requireNonNull(sqlStreamOptimizerComponent);
this.sqlStreamTerminatorComponent = requireNonNull(sqlStreamTerminatorComponent);
this.sqlTraceComponent = sqlTraceComponent;
this.allowIteratorAndSpliterator = allowIteratorAndSpliterator;
final Project project = projectComponent.getProject();
final Table table = DocumentDbUtil.referencedTable(project, tableId);
this.dbms = DocumentDbUtil.referencedDbms(project, tableId);
this.dbmsType = DatabaseUtil.dbmsTypeOf(dbmsHandlerComponent, dbms);
@SuppressWarnings("unchecked")
final Manager<ENTITY> manager = (Manager<ENTITY>) managerComponent.stream()
.filter(m -> tableId.equals(m.getTableIdentifier()))
.findAny().orElseThrow(() -> new SpeedmentException(
"Could not find any manager for table '" + tableId + "'."
));
final DatabaseNamingConvention naming = dbmsType.getDatabaseNamingConvention();
final String sqlColumnList = table.columns()
.filter(Column::isEnabled)
.map(Column::getName)
.map(naming::encloseField)
.collect(joining(","));
this.sqlTableReference = naming.fullNameOf(table);
this.sqlSelect = "SELECT " + sqlColumnList + " FROM " + sqlTableReference;
this.sqlSelectCount = "SELECT COUNT(*) FROM " + sqlTableReference;
this.columnNameMap = manager.fields()
.filter(f -> f.findColumn(project)
.map(HasParent<Table>::getParentOrThrow)
.map(t -> isSame(table, t))
.orElse(false)
)
.map(Field::identifier)
.collect(toMap(identity(), c -> naming.encloseField(c.getColumnId())));
this.columnDatabaseTypeMap = new HashMap<>();
manager.fields()
.forEach(f -> {
final Optional<? extends Column> c = f.findColumn(project);
final Class<?> javaClass = c.orElseThrow(() ->
new SpeedmentException(format("Field '%s' in manager '%s'" +
" referred to a column that couldn't be found " +
"in config model.",
f.identifier().toString(),
manager
))
).findDatabaseType();
columnDatabaseTypeMap.put(f.identifier(), javaClass);
});
}
@Override
public Stream<ENTITY> stream(ParallelStrategy parallelStrategy) {<FILL_FUNCTION_BODY>}
@Override
public <V extends Comparable<? super V>> Optional<ENTITY> findAny(HasComparableOperators<ENTITY, V> field, V value) {
return stream(ParallelStrategy.computeIntensityDefault())
.filter(field.equal(value))
.findAny();
}
public String getSqlTableReference() {
return sqlTableReference;
}
public long executeAndGetLong(String sql, List<Object> values) {
LOGGER_SELECT.debug("%s, values:%s", sql, values);
return dbmsType.getOperationHandler().executeQuery(dbms,
sql,
values,
rs -> rs.getLong(1)
).findAny().orElseThrow(() -> new NoSuchElementException("No long value for " + sql + ", values " + values));
}
private String sqlColumnNamer(Field<ENTITY> field) {
return columnNameMap.get(field.identifier());
}
private Class<?> sqlDatabaseTypeFunction(Field<ENTITY> field) {
return columnDatabaseTypeMap.get(field.identifier());
}
}
|
final AsynchronousQueryResult<ENTITY> asynchronousQueryResult
= dbmsType.getOperationHandler().executeQueryAsync(
dbms,
sqlSelect,
Collections.emptyList(),
entityMapper,
parallelStrategy
);
final SqlStreamOptimizerInfo<ENTITY> info = SqlStreamOptimizerInfo.of(
dbmsType,
sqlSelect,
sqlSelectCount,
this::executeAndGetLong,
this::sqlColumnNamer,
this::sqlDatabaseTypeFunction
);
final SqlTracer sqlTracer = SqlTracer.from(sqlTraceComponent);
final SqlStreamTerminator<ENTITY> terminator = new SqlStreamTerminator<>(
info,
asynchronousQueryResult,
sqlStreamOptimizerComponent,
sqlStreamTerminatorComponent,
sqlTracer,
allowIteratorAndSpliterator
);
final Supplier<BaseStream<?, ?>> initialSupplier
= asynchronousQueryResult::stream;
final Stream<ENTITY> result = new ReferenceStreamBuilder<>(
new PipelineImpl<>(initialSupplier),
terminator
);
// Make sure we are closing the ResultSet, Statement and Connection later
result.onClose(asynchronousQueryResult::close);
return result;
| 1,369
| 325
| 1,694
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/component/sql/SqlTracerImpl.java
|
SqlTracerImpl
|
attachTraceData
|
class SqlTracerImpl implements SqlTracer {
private final SqlTraceComponent sqlTraceComponent;
SqlTracerImpl(final SqlTraceComponent sqlTraceComponent) {
this.sqlTraceComponent = sqlTraceComponent;
}
@Override
public String attachTraceData(final String sql) {<FILL_FUNCTION_BODY>}
}
|
if (sqlTraceComponent == null
|| sqlTraceComponent.getComment() == null
|| sqlTraceComponent.getCommentStyle() == null) {
return sql;
}
final String comment = sqlTraceComponent.getComment();
final DatabaseCommentStyle commentStyle = sqlTraceComponent.getCommentStyle();
final StringBuilder sb = new StringBuilder(sql);
sb.append(" ").append(commentStyle.getPrefix()).append(" ").append(comment).append(" ");
commentStyle.getSuffix().ifPresent(sb::append);
return sb.toString();
| 87
| 145
| 232
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/component/sql/override/def/doubles/DefaultDoubleCountTerminator.java
|
DefaultDoubleCountTerminator
|
apply
|
class DefaultDoubleCountTerminator<ENTITY> implements DoubleCountTerminator<ENTITY> {
private DefaultDoubleCountTerminator() {
}
@Override
public long apply(
final SqlStreamOptimizerInfo<ENTITY> info,
final SqlStreamTerminator<ENTITY> sqlStreamTerminator,
final DoublePipeline pipeline
) {<FILL_FUNCTION_BODY>}
public static final DoubleCountTerminator<?> DEFAULT = new DefaultDoubleCountTerminator<>();
}
|
requireNonNull(info);
requireNonNull(sqlStreamTerminator);
requireNonNull(pipeline);
final DoublePipeline optimizedPipeline = sqlStreamTerminator.optimize(pipeline);
return sqlStreamTerminator
.attachTraceData(optimizedPipeline)
.getAsDoubleStream().count();
| 133
| 86
| 219
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/component/sql/override/def/longs/DefaultLongCountTerminator.java
|
DefaultLongCountTerminator
|
apply
|
class DefaultLongCountTerminator<ENTITY> implements LongCountTerminator<ENTITY> {
private DefaultLongCountTerminator() {
}
@Override
public long apply(
final SqlStreamOptimizerInfo<ENTITY> info,
final SqlStreamTerminator<ENTITY> sqlStreamTerminator,
final LongPipeline pipeline
) {<FILL_FUNCTION_BODY>}
public static final LongCountTerminator<?> DEFAULT = new DefaultLongCountTerminator<>();
}
|
requireNonNull(info);
requireNonNull(sqlStreamTerminator);
requireNonNull(pipeline);
final LongPipeline optimizedPipeline = sqlStreamTerminator.optimize(pipeline);
return sqlStreamTerminator
.attachTraceData(optimizedPipeline)
.getAsLongStream().count();
| 134
| 86
| 220
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/component/sql/override/def/reference/DefaultAllMatchTerminator.java
|
DefaultAllMatchTerminator
|
apply
|
class DefaultAllMatchTerminator<ENTITY> implements AllMatchTerminator<ENTITY> {
private DefaultAllMatchTerminator() {
}
@Override
public <T> boolean apply(
final SqlStreamOptimizerInfo<ENTITY> info,
final SqlStreamTerminator<ENTITY> sqlStreamTerminator,
final ReferencePipeline<T> pipeline,
final Predicate<? super T> predicate
) {<FILL_FUNCTION_BODY>}
public static final AllMatchTerminator<?> DEFAULT = new DefaultAllMatchTerminator<>();
}
|
requireNonNull(info);
requireNonNull(sqlStreamTerminator);
requireNonNull(pipeline);
requireNonNull(predicate);
final ReferencePipeline<T> optimizedPipeline = sqlStreamTerminator.optimize(pipeline);
return sqlStreamTerminator
.attachTraceData(optimizedPipeline)
.getAsReferenceStream().allMatch(predicate);
| 151
| 102
| 253
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/component/sql/override/def/reference/DefaultCollectTerminator.java
|
DefaultCollectTerminator
|
apply
|
class DefaultCollectTerminator<ENTITY> implements CollectTerminator<ENTITY> {
private DefaultCollectTerminator() {
}
@Override
public <T, R, A> R apply(
final SqlStreamOptimizerInfo<ENTITY> info,
final SqlStreamTerminator<ENTITY> sqlStreamTerminator,
final ReferencePipeline<T> pipeline,
final Collector<? super T, A, R> collector
) {<FILL_FUNCTION_BODY>}
public static final CollectTerminator<?> DEFAULT = new DefaultCollectTerminator<>();
}
|
requireNonNull(info);
requireNonNull(sqlStreamTerminator);
requireNonNull(pipeline);
requireNonNull(collector);
final ReferencePipeline<T> optimizedPipeline = sqlStreamTerminator.optimize(pipeline);
return sqlStreamTerminator
.attachTraceData(optimizedPipeline)
.getAsReferenceStream().collect(collector);
| 154
| 101
| 255
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/component/sql/override/def/reference/DefaultFindAnyTerminator.java
|
DefaultFindAnyTerminator
|
apply
|
class DefaultFindAnyTerminator<ENTITY> implements FindAnyTerminator<ENTITY> {
private DefaultFindAnyTerminator() {
}
@Override
public <T> Optional<T> apply(
final SqlStreamOptimizerInfo<ENTITY> info,
final SqlStreamTerminator<ENTITY> sqlStreamTerminator,
final ReferencePipeline<T> pipeline
) {<FILL_FUNCTION_BODY>}
public static final FindAnyTerminator<?> DEFAULT = new DefaultFindAnyTerminator<>();
}
|
requireNonNull(info);
requireNonNull(sqlStreamTerminator);
requireNonNull(pipeline);
final ReferencePipeline<T> optimizedPipeline = sqlStreamTerminator.optimize(pipeline);
return sqlStreamTerminator
.attachTraceData(optimizedPipeline)
.getAsReferenceStream().findAny();
| 142
| 90
| 232
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/component/sql/override/def/reference/DefaultMaxTerminator.java
|
DefaultMaxTerminator
|
apply
|
class DefaultMaxTerminator<ENTITY> implements MaxTerminator<ENTITY> {
private DefaultMaxTerminator() {
}
@Override
public <T> Optional<T> apply(
final SqlStreamOptimizerInfo<ENTITY> info,
final SqlStreamTerminator<ENTITY> sqlStreamTerminator,
final ReferencePipeline<T> pipeline,
final Comparator<? super T> comparator
) {<FILL_FUNCTION_BODY>}
public static final MaxTerminator<?> DEFAULT = new DefaultMaxTerminator<>();
}
|
requireNonNull(info);
requireNonNull(sqlStreamTerminator);
requireNonNull(pipeline);
requireNonNull(comparator);
final ReferencePipeline<T> optimizedPipeline = sqlStreamTerminator.optimize(pipeline);
return sqlStreamTerminator
.attachTraceData(optimizedPipeline)
.getAsReferenceStream().max(comparator);
| 151
| 103
| 254
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/component/sql/override/def/reference/DefaultMinTerminator.java
|
DefaultMinTerminator
|
apply
|
class DefaultMinTerminator<ENTITY> implements MinTerminator<ENTITY> {
private DefaultMinTerminator() {
}
@Override
public <T> Optional<T> apply(
final SqlStreamOptimizerInfo<ENTITY> info,
final SqlStreamTerminator<ENTITY> sqlStreamTerminator,
final ReferencePipeline<T> pipeline,
final Comparator<? super T> comparator
) {<FILL_FUNCTION_BODY>}
public static final MinTerminator<?> DEFAULT = new DefaultMinTerminator<>();
}
|
requireNonNull(info);
requireNonNull(sqlStreamTerminator);
requireNonNull(pipeline);
requireNonNull(comparator);
final ReferencePipeline<T> optimizedPipeline = sqlStreamTerminator.optimize(pipeline);
return sqlStreamTerminator
.attachTraceData(optimizedPipeline)
.getAsReferenceStream().min(comparator);
| 151
| 103
| 254
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/component/sql/override/def/reference/DefaultNoneMatchTerminator.java
|
DefaultNoneMatchTerminator
|
apply
|
class DefaultNoneMatchTerminator<ENTITY> implements NoneMatchTerminator<ENTITY> {
private DefaultNoneMatchTerminator() {
}
@Override
public <T> boolean apply(
final SqlStreamOptimizerInfo<ENTITY> info,
final SqlStreamTerminator<ENTITY> sqlStreamTerminator,
final ReferencePipeline<T> pipeline,
final Predicate<? super T> predicate
) {<FILL_FUNCTION_BODY>}
public static final NoneMatchTerminator<?> DEFAULT = new DefaultNoneMatchTerminator<>();
}
|
requireNonNull(info);
requireNonNull(sqlStreamTerminator);
requireNonNull(pipeline);
requireNonNull(predicate);
final ReferencePipeline<T> optimizedPipeline = sqlStreamTerminator.optimize(pipeline);
return sqlStreamTerminator
.attachTraceData(optimizedPipeline)
.getAsReferenceStream().noneMatch(predicate);
| 151
| 102
| 253
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/component/sql/override/def/reference/DefaultReduceIdentityCombinerTerminator.java
|
DefaultReduceIdentityCombinerTerminator
|
apply
|
class DefaultReduceIdentityCombinerTerminator<ENTITY> implements ReduceIdentityCombinerTerminator<ENTITY> {
private DefaultReduceIdentityCombinerTerminator() {
}
@Override
public <T, U> U apply(
final SqlStreamOptimizerInfo<ENTITY> info,
final SqlStreamTerminator<ENTITY> sqlStreamTerminator,
final ReferencePipeline<T> pipeline,
final U identity,
final BiFunction<U, ? super T, U> accumulator,
final BinaryOperator<U> combiner
) {<FILL_FUNCTION_BODY>}
public static final ReduceIdentityCombinerTerminator<?> DEFAULT = new DefaultReduceIdentityCombinerTerminator<>();
}
|
requireNonNull(info);
requireNonNull(sqlStreamTerminator);
requireNonNull(pipeline);
// identity nullable
requireNonNull(accumulator);
requireNonNull(combiner);
final ReferencePipeline<T> optimizedPipeline = sqlStreamTerminator.optimize(pipeline);
return sqlStreamTerminator
.attachTraceData(optimizedPipeline)
.getAsReferenceStream().reduce(identity, accumulator, combiner);
| 196
| 124
| 320
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/component/sql/override/def/reference/DefaultReduceIdentityTerminator.java
|
DefaultReduceIdentityTerminator
|
apply
|
class DefaultReduceIdentityTerminator<ENTITY> implements ReduceIdentityTerminator<ENTITY> {
private DefaultReduceIdentityTerminator() {
}
@Override
public <T> T apply(
final SqlStreamOptimizerInfo<ENTITY> info,
final SqlStreamTerminator<ENTITY> sqlStreamTerminator,
final ReferencePipeline<T> pipeline,
final T identity,
final BinaryOperator<T> accumulator
) {<FILL_FUNCTION_BODY>}
public static final ReduceIdentityTerminator<?> DEFAULT = new DefaultReduceIdentityTerminator<>();
}
|
requireNonNull(info);
requireNonNull(sqlStreamTerminator);
requireNonNull(pipeline);
// identity nullable
requireNonNull(accumulator);
final ReferencePipeline<T> optimizedPipeline = sqlStreamTerminator.optimize(pipeline);
return sqlStreamTerminator
.attachTraceData(optimizedPipeline)
.getAsReferenceStream().reduce(identity, accumulator);
| 163
| 111
| 274
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/component/sql/override/def/reference/DefaultToArrayGeneratorTerminator.java
|
DefaultToArrayGeneratorTerminator
|
apply
|
class DefaultToArrayGeneratorTerminator<ENTITY> implements ToArrayGeneratorTerminator<ENTITY> {
private DefaultToArrayGeneratorTerminator() {
}
@Override
public <T, A> A[] apply(
final SqlStreamOptimizerInfo<ENTITY> info,
final SqlStreamTerminator<ENTITY> sqlStreamTerminator,
final ReferencePipeline<T> pipeline,
final IntFunction<A[]> generator
) {<FILL_FUNCTION_BODY>}
public static final ToArrayGeneratorTerminator<?> DEFAULT = new DefaultToArrayGeneratorTerminator<>();
}
|
requireNonNull(info);
requireNonNull(sqlStreamTerminator);
requireNonNull(pipeline);
requireNonNull(generator);
final ReferencePipeline<T> optimizedPipeline = sqlStreamTerminator.optimize(pipeline);
return sqlStreamTerminator
.attachTraceData(optimizedPipeline)
.getAsReferenceStream().toArray(generator);
| 159
| 100
| 259
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/component/sql/override/def/reference/DefaultToArrayTerminator.java
|
DefaultToArrayTerminator
|
apply
|
class DefaultToArrayTerminator<ENTITY> implements ToArrayTerminator<ENTITY> {
private DefaultToArrayTerminator() {
}
@Override
public <T> Object[] apply(
final SqlStreamOptimizerInfo<ENTITY> info,
final SqlStreamTerminator<ENTITY> sqlStreamTerminator,
final ReferencePipeline<T> pipeline
) {<FILL_FUNCTION_BODY>}
public static final ToArrayTerminator<?> DEFAULT = new DefaultToArrayTerminator<>();
}
|
requireNonNull(info);
requireNonNull(sqlStreamTerminator);
requireNonNull(pipeline);
final ReferencePipeline<T> optimizedPipeline = sqlStreamTerminator.optimize(pipeline);
return sqlStreamTerminator
.attachTraceData(optimizedPipeline)
.getAsReferenceStream().toArray();
| 140
| 90
| 230
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/component/sql/override/optimized/ints/OptimizedIntCountTerminator.java
|
OptimizedIntCountTerminator
|
apply
|
class OptimizedIntCountTerminator<ENTITY> implements IntCountTerminator<ENTITY> {
private OptimizedIntCountTerminator() {}
@Override
public long apply(
final SqlStreamOptimizerInfo<ENTITY> info,
final SqlStreamTerminator<ENTITY> sqlStreamTerminator,
final IntPipeline pipeline
) {<FILL_FUNCTION_BODY>}
public static final IntCountTerminator<?> INSTANCE = new OptimizedIntCountTerminator<>();
@SuppressWarnings("unchecked")
public static <ENTITY> IntCountTerminator<ENTITY> create() {
return (IntCountTerminator<ENTITY>) INSTANCE;
}
}
|
requireNonNull(info);
requireNonNull(sqlStreamTerminator);
requireNonNull(pipeline);
return countHelper(
info,
sqlStreamTerminator,
pipeline,
() -> IntCountTerminator.<ENTITY>defaultTerminator().apply(info, sqlStreamTerminator, pipeline)
);
| 189
| 89
| 278
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/component/sql/override/optimized/reference/OptimizedCountTerminator.java
|
OptimizedCountTerminator
|
apply
|
class OptimizedCountTerminator<ENTITY> implements CountTerminator<ENTITY> {
private OptimizedCountTerminator() {
}
@Override
public <T> long apply(
final SqlStreamOptimizerInfo<ENTITY> info,
final SqlStreamTerminator<ENTITY> sqlStreamTerminator,
final ReferencePipeline<T> pipeline
) {<FILL_FUNCTION_BODY>}
public static final CountTerminator<?> INSTANCE = new OptimizedCountTerminator<>();
@SuppressWarnings("unchecked")
public static <ENTITY> CountTerminator<ENTITY> create() {
return (CountTerminator<ENTITY>) INSTANCE;
}
}
|
requireNonNull(info);
requireNonNull(sqlStreamTerminator);
requireNonNull(pipeline);
return countHelper(
info,
sqlStreamTerminator,
pipeline,
() -> CountTerminator.<ENTITY>defaultTerminator().apply(info, sqlStreamTerminator, pipeline)
);
| 191
| 88
| 279
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/component/sql/override/optimized/util/CountUtil.java
|
CountUtil
|
countHelper
|
class CountUtil {
private static final Predicate<Action<?, ?>> PRESERVE_SIZE = action -> action.is(PRESERVE, SIZE);
/**
* Optimizer for count operations.
*
* @param <ENTITY> the entity type
* @param info about the stream optimizer
* @param sqlStreamTerminator that called us
* @param pipeline the pipeline
* @param fallbackSupplier a fallback supplier should every item be size
* retaining
* @return the number of rows
*/
public static <ENTITY> long countHelper(
final SqlStreamOptimizerInfo<ENTITY> info,
final SqlStreamTerminator<ENTITY> sqlStreamTerminator,
final Pipeline pipeline,
final LongSupplier fallbackSupplier
) {<FILL_FUNCTION_BODY>}
private CountUtil() {
throw new UnsupportedOperationException();
}
}
|
requireNonNull(info);
requireNonNull(sqlStreamTerminator);
requireNonNull(pipeline);
requireNonNull(fallbackSupplier);
// Can we count it directly (with no sub-select query)?
if (pipeline.stream().allMatch(PRESERVE_SIZE)) {
return info.getCounter().applyAsLong(info.getSqlSelectCount(), emptyList());
} else {
final Pipeline optimizedPipeline = sqlStreamTerminator.optimize(pipeline);
// Can we count using a sub-select query?
if (optimizedPipeline.stream().allMatch(PRESERVE_SIZE)) {
final AsynchronousQueryResult<ENTITY> asynchronousQueryResult = sqlStreamTerminator.getAsynchronousQueryResult();
final StringBuilder sql = new StringBuilder()
.append("SELECT COUNT(*) FROM (")
.append(asynchronousQueryResult.getSql())
.append(")");
if (info.getDbmsType().getSubSelectAlias() == SubSelectAlias.REQUIRED) {
sql.append(" AS A");
}
@SuppressWarnings("unchecked")
final List<Object> values = (List<Object>) asynchronousQueryResult.getValues();
return info.getCounter().applyAsLong(sqlStreamTerminator.attachTraceData(sql.toString()), values);
} else {
// Iterate over all materialized ENTITIES....
return fallbackSupplier.getAsLong();
}
}
| 235
| 375
| 610
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/component/transaction/TransactionHandlerImpl.java
|
TransactionHandlerImpl
|
createAndApply
|
class TransactionHandlerImpl implements TransactionHandler {
private static final Logger TRANSACTION_LOGGER = LoggerManager.getLogger(ApplicationBuilder.LogType.TRANSACTION.getLoggerName());
private final TransactionComponent txComponent;
private final Object dataSource;
private final DataSourceHandler<Object, Object> dataSourceHandler;
private Isolation isolation;
TransactionHandlerImpl(
final TransactionComponent txComponent,
final Object dataSource,
final DataSourceHandler<Object, Object> dataSourceHandler
) {
this.txComponent = requireNonNull(txComponent);
this.dataSource = requireNonNull(dataSource);
this.dataSourceHandler = requireNonNull(dataSourceHandler);
this.isolation = Isolation.DEFAULT;
}
@Override
public void setIsolation(Isolation level) {
this.isolation = level;
}
@Override
public Isolation getIsolation() {
return isolation;
}
public <R> R createAndApply(Function<? super Transaction, ? extends R> mapper) {<FILL_FUNCTION_BODY>}
private Isolation setAndGetIsolation(Object txObject, Isolation isolation) {
if (Isolation.DEFAULT != isolation) {
return dataSourceHandler.isolationConfigurator().apply(txObject, isolation);
} else {
return Isolation.DEFAULT;
}
}
}
|
requireNonNull(mapper);
final Thread currentThread = Thread.currentThread();
final Object txObject = dataSourceHandler.extractor().apply(dataSource); // e.g. obtains a Connection
final Isolation oldIsolation = setAndGetIsolation(txObject, isolation);
final Transaction tx = new TransactionImpl(txComponent, txObject, dataSourceHandler);
TRANSACTION_LOGGER.debug("Transaction %s created for thread '%s' on tranaction object %s", tx, currentThread.getName(), txObject);
txComponent.put(currentThread, txObject);
try {
dataSourceHandler.beginner().accept(txObject); // e.g. con.setAutocommit(false)
return mapper.apply(tx);
} catch (Exception e) {
// Executed in the finally block : dataSourceHandler.rollbacker().accept(txObject); // Automatically rollback if there is an exception
throw new TransactionException("Error while invoking transaction for object :" + txObject, e);
} finally {
dataSourceHandler.rollbacker().accept(txObject); // Always rollback() implicitly and discard uncommitted data
dataSourceHandler.closer().accept(txObject); // e.g. con.setAutocommit(true); con.close();
setAndGetIsolation(txObject, oldIsolation);
txComponent.remove(currentThread);
TRANSACTION_LOGGER.debug("Transaction %s owned by thread '%s' was discarded", tx, currentThread.getName());
}
| 361
| 379
| 740
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/db/DriverComponentImpl.java
|
DriverComponentImpl
|
driverHelper
|
class DriverComponentImpl implements DriverComponent {
// Driver names are cached because getting a Driver
// is expensive and is called within the get connection loop
// in the ConnectionPoolComponent,
// See https://github.com/speedment/speedment/issues/725
// And yes, we should not put Optionals in Maps but
// here it was so convenient. :-)
private final Map<String, Optional<Driver>> cache;
private Injector injector;
public DriverComponentImpl() {
this.cache = new ConcurrentHashMap<>();
}
@ExecuteBefore(STARTED)
public void setInjector(Injector injector) {
this.injector = injector;
}
@Override
public Optional<Driver> driver(String driverName) {
return cache.computeIfAbsent(driverName, this::driverHelper);
}
private Optional<Driver> driverHelper(String driverName) {<FILL_FUNCTION_BODY>}
}
|
requireNonNull(driverName);
Driver driver = null;
try {
final Class<?> driverClass = Class.forName(
driverName,
true,
injector.classLoader()
);
if (Driver.class.isAssignableFrom(driverClass)) {
driver = (Driver) driverClass.getDeclaredConstructor().newInstance();
}
} catch (final ClassNotFoundException ex) {
try {
// Some JavaEE servers, notably Tomcat, runs the driver on the
// standard classloader. This is the reason we need to check an
// extra time.
final Class<?> driverClass = Class.forName(driverName);
if (Driver.class.isAssignableFrom(driverClass)) {
driver = (Driver) driverClass.getDeclaredConstructor().newInstance();
}
} catch (final ClassNotFoundException | IllegalAccessException
| InstantiationException | NoSuchMethodException
| InvocationTargetException ex2) {
// Do nothing.
}
} catch (IllegalAccessException | InstantiationException
| NoSuchMethodException | InvocationTargetException ex3) {
// Do nothing.
}
return Optional.ofNullable(driver);
| 250
| 305
| 555
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/db/JavaTypeMapImpl.java
|
JavaTypeMapImpl
|
findJdbcType
|
class JavaTypeMapImpl implements JavaTypeMap {
private final List<Rule> rules;
private final Map<String, Class<?>> inner;
public JavaTypeMapImpl() {
this(map -> {});
}
/**
* Sets up the java type map for this database type
*
* @param installer the installer
* @see <a href="http://docs.oracle.com/javase/1.5.0/docs/guide/jdbc/getstart/mapping.html">Official Mappings</a>
*/
private JavaTypeMapImpl(Consumer<Map<String, Class<?>>> installer) {
rules = new CopyOnWriteArrayList<>();
inner = newCaseInsensitiveMap();
inner.put("CHAR", String.class);
inner.put("VARCHAR", String.class);
inner.put("LONGVARCHAR", String.class);
inner.put("NUMERIC", BigDecimal.class);
inner.put("DECIMAL", BigDecimal.class);
inner.put("NUMBER", BigDecimal.class);
inner.put("BIT", Integer.class); ///
inner.put("TINYINT", Byte.class);
inner.put("TINYINT UNSIGNED", Short.class);
inner.put("SMALLINT", Short.class);
inner.put("SMALLINT UNSIGNED", Integer.class);
inner.put("INTEGER", Integer.class);
inner.put("INTEGER UNSIGNED", Long.class);
inner.put("BIGINT", Long.class);
inner.put("BIGINT UNSIGNED", BigInteger.class);
inner.put("REAL", Float.class);
inner.put("FLOAT", Double.class);
inner.put("DOUBLE", Double.class);
inner.put("DATE", java.sql.Date.class);
inner.put("DATETIME", Timestamp.class);
inner.put("TIME", Time.class);
inner.put("TIMESTAMP", Timestamp.class);
inner.put("CLOB", Clob.class);
inner.put("BLOB", Blob.class);
inner.put("BOOLEAN", Boolean.class);
inner.put("BOOL", Boolean.class);
//MySQL Specific mappings
inner.put("YEAR", Integer.class);
inner.put("INT UNSIGNED", Long.class);
//PostgreSQL specific mappings
inner.put("UUID", UUID.class);
installer.accept(inner);
rules.add(DEFAULT_RULE);
assertJavaTypesKnown();
}
@Override
public final void addRule(Rule rule) {
rules.add(requireNonNull(rule));
}
@Override
public final Class<?> findJdbcType(Map<String, Class<?>> sqlTypeMapping, ColumnMetaData md) {<FILL_FUNCTION_BODY>}
@Override
public final void put(String key, Class<?> clazz) {
requireNonNulls(key, clazz);
inner.put(key, clazz);
}
@Override
public final Class<?> get(String key) {
requireNonNull(key);
return inner.get(key);
}
private void assertJavaTypesKnown() {
final Map<String, Class<?>> unmapped = new LinkedHashMap<>();
inner.forEach((key, clazz) -> {
if (StandardJavaTypeMapping.stream()
.noneMatch(jtm -> jtm.getJavaClass().equals(clazz))) {
unmapped.put(key, clazz);
}
});
if (!unmapped.isEmpty()) {
throw new SpeedmentException(
"There are mappings that have no " +
StandardJavaTypeMapping.class.getSimpleName() +
" " + unmapped
);
}
}
}
|
// Firstly, check if we have any rule for this type.
final Optional<Class<?>> ruled = rules.stream()
.map(r -> r.findJdbcType(sqlTypeMapping, md))
.filter(Optional::isPresent)
.map(Optional::get)
.findFirst();
if (ruled.isPresent()) {
return ruled.get();
} else {
// Secondly, try md.getTypeName()
final String typeName = md.getTypeName();
final Class<?> innerType = inner.get(typeName);
if (innerType != null) return innerType;
Class<?> result = sqlTypeMapping.get(typeName);
if (result == null) {
// Type (int) according to java.sql.Types (e.g. 4) that
// we got from the ColumnMetaData
final int type = md.getDataType();
// Variable name (String) according to java.sql.Types (e.g. INTEGER)
final Optional<String> oTypeName = TypeInfoMetaData.lookupJavaSqlType(type);
if (oTypeName.isPresent()) {
final String typeName2 = oTypeName.get();
// Thirdly, try the corresponding name using md.getDataType()
// and then lookup java.sql.Types name
result = sqlTypeMapping.get(typeName2);
}
}
return result;
}
| 1,011
| 370
| 1,381
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/db/SqlQueryLoggerUtil.java
|
SqlQueryLoggerUtil
|
logOperation
|
class SqlQueryLoggerUtil {
private SqlQueryLoggerUtil() {}
public static void logOperation(Logger logger, final String sql, final List<?> values) {<FILL_FUNCTION_BODY>}
}
|
if (logger.getLevel().isEqualOrLowerThan(Level.DEBUG)) {
final String text = sql + " " + values.stream()
.map(o -> o == null
? "null"
: o.getClass().getSimpleName() + " " + o.toString())
.collect(Collectors.joining(", ", "[", "]"));
logger.debug(text);
}
| 55
| 105
| 160
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/db/metadata/ColumnMetaDataImpl.java
|
IntHolder
|
readSilent
|
class IntHolder {
private final int value;
private final boolean isNull;
IntHolder(ResultSet rs, SqlIntSupplier supplier) {
int val = 0;
boolean isValueNull= true;
try {
val = supplier.get();
isValueNull = rs.wasNull();
} catch (SQLException sqle) {
// Ignore, value = 0 and wasNull true
}
this.value = val;
this.isNull = isValueNull;
}
public int getValue() {
return value;
}
public boolean isNull() {
return isNull;
}
@Override
public String toString() {
return isNull ? "null" : Integer.toString(value);
}
}
@FunctionalInterface
interface SqlIntSupplier {
int get() throws SQLException;
}
private <T> T readSilent(ResultSet rs, SqlSupplier<T> supplier) {
return readSilent(rs, supplier, true);
}
private <T> T readSilent(ResultSet rs, SqlSupplier<T> supplier, boolean fullWarning) {<FILL_FUNCTION_BODY>
|
try {
final T result = supplier.get();
if (rs.wasNull()) {
return null;
} else {
return result;
}
} catch (SQLException sqle) {
// ignore, just return null
if (fullWarning) {
LOGGER.warn(sqle, "Unable to read column metadata: " + sqle.getMessage());
} else {
LOGGER.info("Metadata not supported: " + sqle.getMessage());
}
}
return null;
| 310
| 131
| 441
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/db/metadata/TypeInfoMetaDataImpl.java
|
TypeInfoMetaDataImpl
|
toString
|
class TypeInfoMetaDataImpl implements TypeInfoMetaData {
//http://docs.oracle.com/javase/7/docs/api/java/sql/DatabaseMetaData.html#getTypeInfo()
private final String sqlTypeName;
private final int javaSqlTypeInt;
private final int precision;
private final int decimals;
private final short nullable;
private final boolean unsigned;
public TypeInfoMetaDataImpl(String sqlTypeName, int javaSqlTypeInt, int precision, int decimals, short nullable, boolean unsigned) {
this.sqlTypeName = requireNonNull(sqlTypeName);
this.javaSqlTypeInt = javaSqlTypeInt;
this.precision = precision;
this.decimals = decimals;
this.nullable = nullable;
this.unsigned = unsigned;
}
// private static final Map<Integer, String> JAVA_SQL_TYPE_INT_TO_STRING_MAP = new HashMap<>();
//
// static {
// // Get all field in java.sql.Types using reflection
// final Field[] fields = java.sql.Types.class.getFields();
// for (final Field field : fields) {
// try {
// final String name = field.getName();
// final Integer value = (Integer) field.get(null);
// JAVA_SQL_TYPE_INT_TO_STRING_MAP.put(value, name);
// } catch (final IllegalAccessException e) {
// throw new SpeedmentException(e);
// }
// }
// }
@Override
public String getSqlTypeName() {
return sqlTypeName;
}
@Override
public int getJavaSqlTypeInt() {
return javaSqlTypeInt;
}
@Override
public int getPrecision() {
return precision;
}
@Override
public int getDecimals() {
return decimals;
}
@Override
public short getNullable() {
return nullable;
}
@Override
public boolean isNoNulls() {
return nullable == DatabaseMetaData.attributeNoNulls;
}
@Override
public boolean isNullable() {
return nullable == DatabaseMetaData.attributeNullable;
}
@Override
public boolean isNullableUnknown() {
return nullable == DatabaseMetaData.attributeNullableUnknown;
}
@Override
public boolean isUnsigned() {
return unsigned;
}
@Override
public String toString() {<FILL_FUNCTION_BODY>}
}
|
return getSqlTypeName()
+ " " + (isUnsigned() ? "UNSIGNED" : "")
+ " " + getPrecision()
+ " " + getDecimals()
+ " " + (isNullable() ? "NULL" : "")
+ " " + (isNoNulls() ? "NOT NULL" : "")
+ " (" + getJavaSqlTypeInt() + ")";
| 652
| 106
| 758
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/manager/ConfiguredManager.java
|
ConfiguredManager
|
toString
|
class ConfiguredManager<ENTITY> implements Manager<ENTITY> {
private final StreamSupplierComponent streamSupplierComponent;
private final Manager<ENTITY> manager;
private final ParallelStrategy parallelStrategy;
ConfiguredManager(StreamSupplierComponent streamSupplierComponent,
Manager<ENTITY> manager,
ParallelStrategy parallelStrategy) {
this.streamSupplierComponent = requireNonNull(streamSupplierComponent);
this.manager = requireNonNull(manager);
this.parallelStrategy = requireNonNull(parallelStrategy);
}
@Override
public TableIdentifier<ENTITY> getTableIdentifier() {
return manager.getTableIdentifier();
}
@Override
public Class<ENTITY> getEntityClass() {
return manager.getEntityClass();
}
@Override
public Stream<Field<ENTITY>> fields() {
return manager.fields();
}
@Override
public Stream<Field<ENTITY>> primaryKeyFields() {
return manager.primaryKeyFields();
}
@Override
public Stream<ENTITY> stream() {
return streamSupplierComponent.stream(
getTableIdentifier(),
parallelStrategy
);
}
@Override
public ENTITY create() {
return manager.create();
}
@Override
public Persister<ENTITY> persister() {
return manager.persister();
}
@Override
public Persister<ENTITY> persister(HasLabelSet<ENTITY> fields) {
return manager.persister(fields);
}
@Override
public Updater<ENTITY> updater() {
return manager.updater();
}
@Override
public Updater<ENTITY> updater(HasLabelSet<ENTITY> fields) {
return manager.updater(fields);
}
@Override
public Remover<ENTITY> remover() {
return manager.remover();
}
@Override
public String toString() {<FILL_FUNCTION_BODY>}
}
|
return "ConfiguredManager{" +
"manager=" + manager +
", parallelStrategy=" + parallelStrategy +
'}';
| 522
| 38
| 560
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/stream/autoclose/AutoClosingIntStream.java
|
AutoClosingIntStream
|
toArray
|
class AutoClosingIntStream
extends AbstractAutoClosingStream<Integer, IntStream>
implements IntStream, Java9IntStreamAdditions {
AutoClosingIntStream(
final IntStream stream,
final boolean allowStreamIteratorAndSpliterator
) {
super(stream, allowStreamIteratorAndSpliterator);
}
@Override
public IntStream filter(IntPredicate predicate) {
return wrap(stream().filter(predicate));
}
@Override
public IntStream map(IntUnaryOperator mapper) {
return wrap(stream().map(mapper));
}
@Override
public <U> Stream<U> mapToObj(IntFunction<? extends U> mapper) {
return wrap(stream().mapToObj(mapper));
}
@Override
public LongStream mapToLong(IntToLongFunction mapper) {
return wrap(stream().mapToLong(mapper));
}
@Override
public DoubleStream mapToDouble(IntToDoubleFunction mapper) {
return wrap(stream().mapToDouble(mapper));
}
@Override
public IntStream flatMap(IntFunction<? extends IntStream> mapper) {
return wrap(stream().flatMap(mapper));
}
@Override
public IntStream distinct() {
return wrap(stream().distinct());
}
@Override
public IntStream sorted() {
return wrap(stream().sorted());
}
@Override
public IntStream peek(IntConsumer action) {
return wrap(stream().peek(action));
}
@Override
public IntStream limit(long maxSize) {
return wrap(stream().limit(maxSize));
}
@Override
public IntStream skip(long n) {
return wrap(stream().skip(n));
}
@Override
public IntStream takeWhile(IntPredicate predicate) {
return wrap(Java9StreamUtil.takeWhile(stream(), predicate));
}
@Override
public IntStream dropWhile(IntPredicate predicate) {
return wrap(Java9StreamUtil.dropWhile(stream(), predicate));
}
@Override
public void forEach(IntConsumer action) {
finallyClose(() -> stream().forEach(action));
}
@Override
public void forEachOrdered(IntConsumer action) {
finallyClose(() -> stream().forEachOrdered(action));
}
@Override
public int[] toArray() {<FILL_FUNCTION_BODY>}
@Override
public int reduce(int identity, IntBinaryOperator op) {
return finallyClose(() -> stream().reduce(identity, op));
}
@Override
public OptionalInt reduce(IntBinaryOperator op) {
return finallyClose(() -> stream().reduce(op));
}
@Override
public <R> R collect(Supplier<R> supplier, ObjIntConsumer<R> accumulator, BiConsumer<R, R> combiner) {
return finallyClose(() -> stream().collect(supplier, accumulator, combiner));
}
@Override
public int sum() {
return finallyClose(stream()::sum);
}
@Override
public OptionalInt min() {
return finallyClose(stream()::min);
}
@Override
public OptionalInt max() {
return finallyClose(stream()::max);
}
@Override
public long count() {
return finallyClose(stream()::count);
}
@Override
public OptionalDouble average() {
return finallyClose(stream()::average);
}
@Override
public IntSummaryStatistics summaryStatistics() {
return finallyClose(stream()::summaryStatistics);
}
@Override
public boolean anyMatch(IntPredicate predicate) {
return finallyClose(() -> stream().anyMatch(predicate));
}
@Override
public boolean allMatch(IntPredicate predicate) {
return finallyClose(() -> stream().allMatch(predicate));
}
@Override
public boolean noneMatch(IntPredicate predicate) {
return finallyClose(() -> stream().noneMatch(predicate));
}
@Override
public OptionalInt findFirst() {
return finallyClose(stream()::findFirst);
}
@Override
public OptionalInt findAny() {
return finallyClose(stream()::findAny);
}
@Override
public LongStream asLongStream() {
return wrap(stream().asLongStream());
}
@Override
public DoubleStream asDoubleStream() {
return wrap(stream().asDoubleStream());
}
@Override
public Stream<Integer> boxed() {
return wrap(stream().boxed());
}
@Override
public IntStream sequential() {
return wrap(stream().sequential());
}
@Override
public IntStream parallel() {
return wrap(stream().parallel());
}
@Override
public PrimitiveIterator.OfInt iterator() {
if (isAllowStreamIteratorAndSpliterator()) {
return stream().iterator();
}
throw newUnsupportedException("iterator");
}
@Override
public Spliterator.OfInt spliterator() {
if (isAllowStreamIteratorAndSpliterator()) {
return stream().spliterator();
}
throw newUnsupportedException("spliterator");
}
@Override
public boolean isParallel() {
return stream().isParallel();
}
@Override
public IntStream unordered() {
return wrap(stream().unordered());
}
@Override
public IntStream onClose(Runnable closeHandler) {
return wrap(stream().onClose(closeHandler));
}
}
|
try {
return stream().toArray();
} finally {
stream().close();
}
| 1,460
| 29
| 1,489
|
<methods>public void close() <variables>private final non-sealed boolean allowStreamIteratorAndSpliterator,private final non-sealed java.util.concurrent.atomic.AtomicBoolean closed,private final non-sealed java.util.stream.IntStream stream
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/stream/autoclose/AutoClosingLongStream.java
|
AutoClosingLongStream
|
toArray
|
class AutoClosingLongStream
extends AbstractAutoClosingStream<Long, LongStream>
implements LongStream, Java9LongStreamAdditions {
AutoClosingLongStream(
final LongStream stream,
final boolean allowStreamIteratorAndSpliterator
) {
super(stream, allowStreamIteratorAndSpliterator);
}
@Override
public LongStream filter(LongPredicate predicate) {
return wrap(stream().filter(predicate));
}
@Override
public LongStream map(LongUnaryOperator mapper) {
return wrap(stream().map(mapper));
}
@Override
public <U> Stream<U> mapToObj(LongFunction<? extends U> mapper) {
return wrap(stream().mapToObj(mapper));
}
@Override
public IntStream mapToInt(LongToIntFunction mapper) {
return wrap(stream().mapToInt(mapper));
}
@Override
public DoubleStream mapToDouble(LongToDoubleFunction mapper) {
return wrap(stream().mapToDouble(mapper));
}
@Override
public LongStream flatMap(LongFunction<? extends LongStream> mapper) {
return wrap(stream().flatMap(mapper));
}
@Override
public LongStream distinct() {
return wrap(stream().distinct());
}
@Override
public LongStream sorted() {
return wrap(stream().sorted());
}
@Override
public LongStream peek(LongConsumer action) {
return wrap(stream().peek(action));
}
@Override
public LongStream limit(long maxSize) {
return wrap(stream().limit(maxSize));
}
@Override
public LongStream skip(long n) {
return wrap(stream().skip(n));
}
@Override
public LongStream takeWhile(LongPredicate predicate) {
return wrap(Java9StreamUtil.takeWhile(stream(), predicate));
}
@Override
public LongStream dropWhile(LongPredicate predicate) {
return wrap(Java9StreamUtil.dropWhile(stream(), predicate));
}
@Override
public void forEach(LongConsumer action) {
finallyClose(() -> stream().forEach(action));
}
@Override
public void forEachOrdered(LongConsumer action) {
finallyClose(() -> stream().forEachOrdered(action));
}
@Override
public long[] toArray() {<FILL_FUNCTION_BODY>}
@Override
public long reduce(long identity, LongBinaryOperator op) {
return finallyClose(() -> stream().reduce(identity, op));
}
@Override
public OptionalLong reduce(LongBinaryOperator op) {
return finallyClose(() -> stream().reduce(op));
}
@Override
public <R> R collect(Supplier<R> supplier, ObjLongConsumer<R> accumulator, BiConsumer<R, R> combiner) {
return finallyClose(() -> stream().collect(supplier, accumulator, combiner));
}
@Override
public long sum() {
return finallyClose(stream()::sum);
}
@Override
public OptionalLong min() {
return finallyClose(stream()::min);
}
@Override
public OptionalLong max() {
return finallyClose(stream()::max);
}
@Override
public long count() {
return finallyClose(stream()::count);
}
@Override
public OptionalDouble average() {
return finallyClose(stream()::average);
}
@Override
public LongSummaryStatistics summaryStatistics() {
return finallyClose(stream()::summaryStatistics);
}
@Override
public boolean anyMatch(LongPredicate predicate) {
return finallyClose(() -> stream().anyMatch(predicate));
}
@Override
public boolean allMatch(LongPredicate predicate) {
return finallyClose(() -> stream().allMatch(predicate));
}
@Override
public boolean noneMatch(LongPredicate predicate) {
return finallyClose(() -> stream().noneMatch(predicate));
}
@Override
public OptionalLong findFirst() {
return finallyClose(stream()::findFirst);
}
@Override
public OptionalLong findAny() {
return finallyClose(stream()::findAny);
}
@Override
public DoubleStream asDoubleStream() {
return wrap(stream().asDoubleStream());
}
@Override
public Stream<Long> boxed() {
return wrap(stream().boxed());
}
@Override
public LongStream sequential() {
return wrap(stream().sequential());
}
@Override
public LongStream parallel() {
return wrap(stream().parallel());
}
@Override
public PrimitiveIterator.OfLong iterator() {
if (isAllowStreamIteratorAndSpliterator()) {
return stream().iterator();
}
throw newUnsupportedException("iterator");
}
@Override
public Spliterator.OfLong spliterator() {
if (isAllowStreamIteratorAndSpliterator()) {
return stream().spliterator();
}
throw newUnsupportedException("spliterator");
}
@Override
public boolean isParallel() {
return stream().isParallel();
}
@Override
public LongStream unordered() {
return wrap(stream().unordered());
}
@Override
public LongStream onClose(Runnable closeHandler) {
return wrap(stream().onClose(closeHandler));
}
}
|
try {
return stream().toArray();
} finally {
close();
}
| 1,431
| 27
| 1,458
|
<methods>public void close() <variables>private final non-sealed boolean allowStreamIteratorAndSpliterator,private final non-sealed java.util.concurrent.atomic.AtomicBoolean closed,private final non-sealed java.util.stream.LongStream stream
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/stream/builder/AbstractStreamBuilder.java
|
AbstractStreamBuilder
|
pipeline
|
class AbstractStreamBuilder<T extends AbstractStreamBuilder<T, P>, P> {
private static final Logger LOGGER = LoggerManager.getLogger(AbstractStreamBuilder.class);
protected final PipelineImpl<?> pipeline;
protected final StreamTerminator streamTerminator;
protected final Set<BaseStream<?, ?>> streamSet; // Keeps track of the chain of streams so that we can auto-close them all
private final List<Runnable> closeHandlers; // The close handlers for this particular stream
private boolean closed;
private boolean linkedOrConsumed;
AbstractStreamBuilder(PipelineImpl<?> pipeline, StreamTerminator streamTerminator, Set<BaseStream<?, ?>> streamSet) {
this.pipeline = requireNonNull(pipeline);
this.streamTerminator = requireNonNull(streamTerminator);
this.closeHandlers = new ArrayList<>();
this.streamSet = streamSet;
this.linkedOrConsumed = false;
}
protected T append(Action<?, ?> newAction) {
requireNonNull(newAction);
pipeline.add(newAction);
return self();
}
public T sequential() {
pipeline.setParallel(false);
return self();
}
public T parallel() {
pipeline.setParallel(true);
return self();
}
public boolean isParallel() {
return pipeline.isParallel();
}
public T unordered() {
pipeline.setOrdered(false);
return self();
}
public T onClose(Runnable closeHandler) {
requireNonNull(closeHandler);
closeHandlers.add(closeHandler);
return self();
}
public void close() {
if (!closed) {
closed = true;
try {
if (!closeHandlers.isEmpty()) {
ComposeRunnableUtil.composedRunnable(closeHandlers); // Run this stream's close handlers
}
} catch (Exception e) {
throw new SpeedmentException(e);
} finally {
ComposeRunnableUtil.composedClose(streamSet.toArray(new AutoCloseable[0])); // Close the other streams
}
}
}
protected void assertNotLinkedOrConsumedAndSet() {
if (linkedOrConsumed) {
throw new IllegalStateException("stream has already been operated upon or has been consumed");
}
linkedOrConsumed = true;
}
protected P pipeline() {<FILL_FUNCTION_BODY>}
private T self() {
@SuppressWarnings("unchecked")
final T thizz = (T) this;
return thizz;
}
protected boolean finallyCloseBoolean(BooleanSupplier bs) {
try {
return bs.getAsBoolean();
} catch (Exception e) {
LOGGER.error(e);
throw e;
} finally {
close();
}
}
protected long finallyCloseLong(LongSupplier lp) {
try {
return lp.getAsLong();
} catch (Exception e) {
LOGGER.error(e);
throw e;
} finally {
close();
}
}
protected int finallyCloseInt(IntSupplier is) {
try {
return is.getAsInt();
} catch (Exception e) {
LOGGER.error(e);
throw e;
} finally {
close();
}
}
protected double finallyCloseDouble(DoubleSupplier ds) {
try {
return ds.getAsDouble();
} catch (Exception e) {
LOGGER.error(e);
throw e;
} finally {
close();
}
}
protected void finallyClose(Runnable r) {
try {
r.run();
} catch (Exception e) {
LOGGER.error(e);
throw e;
} finally {
close();
}
}
protected <T> T finallyCloseReference(Supplier<T> s) {
try {
return s.get();
} catch (Exception e) {
LOGGER.error(e);
throw e;
} finally {
close();
}
}
protected static Set<BaseStream<?, ?>> newStreamSet() {
return new HashSet<>();
}
}
|
@SuppressWarnings("unchecked")
final P result = (P) pipeline;
return result;
| 1,123
| 31
| 1,154
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/stream/builder/streamterminator/StreamTerminatorUtil.java
|
RenderResultImpl
|
renderSqlWhereHelper
|
class RenderResultImpl implements RenderResult {
private final String sql;
private final List<Object> values;
RenderResultImpl(String sql, List<Object> values /*, Pipeline pipeline*/) {
this.sql = sql;
this.values = values;
}
@Override
public String getSql() {
return sql;
}
@Override
public List<Object> getValues() {
return values;
}
@Override
public String toString() {
return String.format("RenderResultImpl {sql=%s, values=%s}", sql, values);
}
}
public static <ENTITY> RenderResult renderSqlWhere(
final DbmsType dbmsType,
final Function<Field<ENTITY>, String> columnNamer,
final Function<Field<ENTITY>, Class<?>> columnDbTypeFunction,
final List<Predicate<ENTITY>> predicates
) {
final FieldPredicateView predicateView = dbmsType.getFieldPredicateView();
final StringBuilder sql = new StringBuilder();
final List<Object> values = new ArrayList<>();
final AtomicInteger cnt = new AtomicInteger();
predicates
.stream()
// Optimize away ALWAYS_TRUE. Fix #495
.filter(p -> {
if (p instanceof FieldPredicate) {
return ((FieldPredicate)p).getPredicateType() != PredicateType.ALWAYS_TRUE;
} else {
return true;
}
})
.forEach(predicate -> {
if (cnt.getAndIncrement() != 0) {
sql.append(" AND ");
}
renderSqlWhereHelper(predicateView, columnNamer, columnDbTypeFunction, sql, values, predicate);
});
return new RenderResultImpl(sql.toString(), values);
}
// See JoinSqlUtil::renderPredicateHelper for JOIN streams
private static <ENTITY> void renderSqlWhereHelper(
final FieldPredicateView spv,
final Function<Field<ENTITY>, String> columnNamer,
final Function<Field<ENTITY>, Class<?>> columnDbTypeFunction,
final StringBuilder sql,
final List<Object> values,
final Predicate<ENTITY> predicate
) {<FILL_FUNCTION_BODY>
|
if (predicate instanceof FieldPredicate) {
final FieldPredicate<ENTITY> fieldPredicate = (FieldPredicate<ENTITY>) predicate;
final SqlPredicateFragment fragment = spv.transform(columnNamer, columnDbTypeFunction, fieldPredicate);
final Field<ENTITY> referenceFieldTrait = fieldPredicate.getField();
@SuppressWarnings("unchecked")
final TypeMapper<Object, Object> tm = (TypeMapper<Object, Object>) referenceFieldTrait.typeMapper();
sql.append(fragment.getSql());
fragment.objects().map(tm::toDatabaseType).forEachOrdered(values::add);
} else if (predicate instanceof CombinedPredicate) {
final CombinedPredicate<ENTITY> combinedPredicate = (CombinedPredicate<ENTITY>) predicate;
final StringBuilder internalSql = new StringBuilder();
final List<Object> internalValues = new ArrayList<>();
final AtomicInteger cnt = new AtomicInteger();
combinedPredicate.stream().forEachOrdered(internalPredicate -> {
if (cnt.getAndIncrement() != 0) {
internalSql.append(" ").append(combinedPredicate.getType().toString()).append(" ");
}
@SuppressWarnings("unchecked")
final Predicate<ENTITY> castedInternalPredicate = (Predicate<ENTITY>) internalPredicate;
renderSqlWhereHelper(
spv,
columnNamer,
columnDbTypeFunction,
internalSql,
internalValues,
castedInternalPredicate
);
});
sql.append("(").append(internalSql).append(")");
values.addAll(internalValues);
} else {
throw new IllegalArgumentException("A predicate that is nether an instanceof FieldPredicate nor CombinedPredicate was given:" + predicate.toString());
}
| 599
| 461
| 1,060
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/stream/parallel/ArraySpliterator.java
|
ArraySpliterator
|
forEachRemaining
|
class ArraySpliterator<T> implements Spliterator<T> {
private final Object[] array;
private final int size;
private final int characteristics;
private int index;
/**
* Creates a {@link Spliterator} covering all of the given array.
*
* @param array the array, assumed to be unmodified during use
* @param additionalCharacteristics Additional {@link Spliterator}
* characteristics of this {@link Spliterator}'s source or elements beyond
* {@code SIZED} and {@code SUBSIZED} which are are always reported
*/
ArraySpliterator(Object[] array, int additionalCharacteristics) {
this(array, 0, array.length, additionalCharacteristics);
}
/**
* Creates a {@link Spliterator} covering the given array and range.
*
* @param array the array, assumed to be unmodified during use
* @param origin the least index (inclusive) to cover
* @param size one past the greatest index to cover
* @param additionalCharacteristics Additional {@link Spliterator}
* characteristics of this {@link Spliterator}'s source or elements beyond
* {@code SIZED} and {@code SUBSIZED} which are are always reported
*/
ArraySpliterator(Object[] array, int origin, int size, int additionalCharacteristics) {
this.array = requireNonNull(array);
this.index = origin;
this.size = size;
this.characteristics = additionalCharacteristics | Spliterator.SIZED | Spliterator.SUBSIZED;
}
@Override
public Spliterator<T> trySplit() {
final int lo = index;
final int mid = (lo + size) >>> 1;
if (lo >= mid) {
return null;
} else {
index = mid;
return new ArraySpliterator<>(array, lo, index, characteristics);
}
}
@SuppressWarnings("unchecked")
@Override
public void forEachRemaining(Consumer<? super T> action) {<FILL_FUNCTION_BODY>}
@Override
public boolean tryAdvance(Consumer<? super T> action) {
requireNonNull(action);
if (index >= 0 && index < size) {
@SuppressWarnings("unchecked")
final T e = (T) array[index++];
action.accept(e);
return true;
}
return false;
}
@Override
public long estimateSize() {
return (long) size - index;
}
@Override
public int characteristics() {
return characteristics;
}
@Override
public Comparator<? super T> getComparator() {
if (hasCharacteristics(Spliterator.SORTED)) {
return null;
}
throw new IllegalStateException();
}
}
|
requireNonNull(action);
int i;
int hi;
if (array.length >= (hi = size) && (i = index) >= 0 && i < (index = hi)) {
do {
action.accept((T) array[i]);
} while (++i < hi);
}
| 732
| 80
| 812
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/util/Cast.java
|
Cast
|
castOrFail
|
class Cast {
private Cast() {}
/**
* Casts and returns the provided object if it is assignable from the given
* class, otherwise returns an Optional.empty().
*
* @param <T> the type to return
* @param object to cast
* @param clazz to cast to
* @return An Optional of the casted element or Optional.empty()
*/
public static <T> Optional<T> cast(Object object, Class<T> clazz) {
requireNonNull(clazz);
if (object == null) {
return Optional.empty();
}
if (clazz.isAssignableFrom(object.getClass())) {
final T result = clazz.cast(object);
return Optional.of(result);
}
return Optional.empty();
}
/**
* Casts and returns the provided object to the provided class.
*
* @param <T> the type to return
* @param object to cast
* @param clazz to cast to
* @return the casted element
* @throws NoSuchElementException if the object could not be casted to the
* provided class
*/
public static <T> T castOrFail(Object object, Class<T> clazz) {<FILL_FUNCTION_BODY>}
}
|
requireNonNull(clazz);
if (object == null) {
throw new NoSuchElementException("null is not an instance of " + clazz.getName());
}
return Optional.of(object)
.filter(o -> clazz.isAssignableFrom(o.getClass()))
.map(clazz::cast)
.orElseThrow(NoSuchElementException::new);
| 330
| 102
| 432
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/internal/util/InternalEmailUtil.java
|
InternalEmailUtil
|
getUserId
|
class InternalEmailUtil {
private InternalEmailUtil() {}
private static final String ID_FIELD_NAME = "user_id";
private static final String EMAIL_FIELD_NAME = "user_mail";
private static final String DEFAULT_EMAIL = "no-mail-specified";
private static final Preferences PREFERENCES =
Preferences.userNodeForPackage(InternalEmailUtil.class);
public static boolean hasEmail() {
final String storedEmail = PREFERENCES.get(EMAIL_FIELD_NAME, null);
if (storedEmail == null) {
return false;
}
return !DEFAULT_EMAIL.equals(storedEmail);
}
public static String getEmail() {
return Optional.ofNullable(
PREFERENCES.get(EMAIL_FIELD_NAME, null)
).orElse(DEFAULT_EMAIL);
}
public static void removeEmail() {
PREFERENCES.remove(EMAIL_FIELD_NAME);
}
public static void setEmail(String email) {
requireNonNull(email);
PREFERENCES.put(EMAIL_FIELD_NAME, email);
}
public static UUID getUserId() {<FILL_FUNCTION_BODY>}
}
|
final String id = PREFERENCES.get(ID_FIELD_NAME, "");
try {
return UUID.fromString(id);
} catch (final IllegalArgumentException ex) {
final UUID generated = UUID.randomUUID();
PREFERENCES.put(ID_FIELD_NAME, generated.toString());
return generated;
}
| 327
| 89
| 416
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/stream/ComposeRunnableUtil.java
|
ComposeRunnableUtil
|
composedRunnable
|
class ComposeRunnableUtil {
private ComposeRunnableUtil() {}
/**
* Given a number of streams, closes the streams in sequence, even if one or
* several throws an Exception. If several throw exceptions, the exceptions
* will be added to the first exception.
*
* @param <T> Stream type
* @param closeables to close
* @throws SpeedmentException if at least one of the close() operations
* throws an exception
*/
@SafeVarargs // Creating a Stream of an array is safe.
@SuppressWarnings({"unchecked", "varargs"})
public static <T extends AutoCloseable> void composedClose(T... closeables) {
requireNonNullElements(closeables);
Exception exception = null;
for (final T closable : closeables) {
try {
closable.close();
} catch (Exception e) {
if (exception == null) {
exception = e;
} else {
try {
exception.addSuppressed(e);
} catch (Exception ignored) {
// No op
}
}
}
}
if (exception != null) {
throw new SpeedmentException(exception);
}
}
/**
* Given a number of Runnables, runs the run() method in sequence, even if
* one or several throws an Exception. If several throw exceptions, the
* exceptions will be added to the first exception.
*
* @param runnables to close
* @throws SpeedmentException if at least one of the run() operations throws
* an exception
*/
public static void composedRunnable(Collection<Runnable> runnables) {<FILL_FUNCTION_BODY>}
private static class CloseImpl implements AutoCloseable {
private final Runnable r;
private CloseImpl(Runnable r) {
this.r = requireNonNull(r);
}
@Override
public void close() { r.run(); }
}
}
|
requireNonNullElements(runnables);
final AutoCloseable[] closables = new AutoCloseable[runnables.size()];
int i = 0;
for (final Runnable r : runnables) {
closables[i++] = new CloseImpl(r);
}
composedClose(closables);
| 513
| 84
| 597
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/util/OptionalUtil.java
|
OptionalUtil
|
ofNullable
|
class OptionalUtil {
private OptionalUtil() {}
/**
* If the specified object is an {@code Optional}, the inner value will be
* returned. Otherwise, the object is returned directly.
*
* @param potentiallyOptional the object that might be an {@code Optional}
* @return the object or its inner value
*/
public static Object unwrap(Object potentiallyOptional) {
if (potentiallyOptional instanceof Optional<?>) {
return unwrap((Optional<?>) potentiallyOptional);
} else {
return potentiallyOptional;
}
}
/**
* Returns the inner value of the {@code Optional} unless the optional
* is {@code null}, in which case {@code null} is returned.
*
* @param <T> the inner type
* @param optional the optional
* @return the inner value or {@code null}
*/
public static <T> T unwrap(@SuppressWarnings("OptionalUsedAsFieldOrParameterType") Optional<T> optional) {
if ((Object) optional == null) { // (Object) cast suppress SonarCube warning
return null;
}
return optional.orElse(null);
}
/**
* Convert an optional value to a boxed one. If the inner value is
* empty, {@code null} will be returned.
*
* @param optional the optional value (or null)
* @return the inner value or {@code null}
*/
public static Integer unwrap(@SuppressWarnings("OptionalUsedAsFieldOrParameterType") OptionalInt optional) {
if (optional == null) {
return null;
} else {
return optional.isPresent() ? optional.getAsInt() : null;
}
}
/**
* Convert an optional value to a boxed one. If the inner value is
* empty, {@code null} will be returned.
*
* @param optional the optional value (or null)
* @return the inner value or {@code null}
*/
public static Boolean unwrap(OptionalBoolean optional) {
if (optional == null) {
return null;
} else {
return optional.isPresent() ? optional.getAsBoolean() : null;
}
}
/**
* Convert an optional value to a boxed one. If the inner value is
* empty, {@code null} will be returned.
*
* @param optional the optional value (or null)
* @return the inner value or {@code null}
*/
public static Long unwrap(@SuppressWarnings("OptionalUsedAsFieldOrParameterType") OptionalLong optional) {
if (optional == null) {
return null;
} else {
return optional.isPresent() ? optional.getAsLong() : null;
}
}
/**
* Convert an optional value to a boxed one. If the inner value is
* empty, {@code null} will be returned.
*
* @param optional the optional value (or null)
* @return the inner value or {@code null}
*/
public static Double unwrap(@SuppressWarnings("OptionalUsedAsFieldOrParameterType") OptionalDouble optional) {
if (optional == null) {
return null;
} else {
return optional.isPresent() ? optional.getAsDouble() : null;
}
}
/**
* Wraps the specified nullable value in an {@code OptionalLong}.
*
* @param l the value
* @return the wrapped optional
*/
public static OptionalLong ofNullable(Long l) {
if (l == null) {
return OptionalLong.empty();
} else {
return OptionalLong.of(l);
}
}
/**
* Wraps the specified nullable value in an {@code OptionalInteger}.
*
* @param i the value
* @return the wrapped optional
*/
public static OptionalInt ofNullable(Integer i) {<FILL_FUNCTION_BODY>}
/**
* Wraps the specified nullable value in an {@code OptionalDouble}.
*
* @param d the value
* @return the wrapped optional
*/
public static OptionalDouble ofNullable(Double d) {
if (d == null) {
return OptionalDouble.empty();
} else {
return OptionalDouble.of(d);
}
}
/**
* Wraps the specified nullable value in an {@code OptionalBoolean}.
*
* @param b the value
* @return the wrapped optional
*/
public static OptionalBoolean ofNullable(Boolean b) {
if (b == null) {
return OptionalBoolean.empty();
} else {
return OptionalBoolean.of(b);
}
}
/**
* Parses the specified value into an optional unless it is {@code null},
* in which case an empty optional is returned.
*
* @param value the value (or null)
* @return the wrapped optional
*/
public static OptionalLong parseLong(String value) {
if (value == null) {
return OptionalLong.empty();
} else {
return OptionalLong.of(Long.parseLong(value));
}
}
/**
* Parses the specified value into an optional unless it is {@code null},
* in which case an empty optional is returned.
*
* @param value the value (or null)
* @return the wrapped optional
*/
public static OptionalInt parseInt(String value) {
if (value == null) {
return OptionalInt.empty();
} else {
return OptionalInt.of(Integer.parseInt(value));
}
}
/**
* Parses the specified value into an optional unless it is {@code null},
* in which case an empty optional is returned.
*
* @param value the value (or null)
* @return the wrapped optional
*/
public static OptionalDouble parseDouble(String value) {
if (value == null) {
return OptionalDouble.empty();
} else {
return OptionalDouble.of(Double.parseDouble(value));
}
}
/**
* Parses the specified value into an optional unless it is {@code null},
* in which case an empty optional is returned.
*
* @param value the value (or null)
* @return the wrapped optional
*/
public static OptionalBoolean parseBoolean(String value) {
if (value == null) {
return OptionalBoolean.empty();
} else {
return OptionalBoolean.of(Boolean.parseBoolean(value));
}
}
}
|
if (i == null) {
return OptionalInt.empty();
} else {
return OptionalInt.of(i);
}
| 1,704
| 38
| 1,742
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/util/Statistics.java
|
Statistics
|
report
|
class Statistics {
private static final String HOST_NAME = computerName();
private static final long STARTED = Instant.now(Clock.system(ZoneId.of("UTC"))).getEpochSecond();
private Statistics() {}
public enum Event {
GUI_STARTED ("gui-started"),
GUI_PROJECT_LOADED ("gui-project-loaded"),
GENERATE ("generate"),
NODE_STARTED ("node-started"),
NODE_ALIVE ("node-alive"),
NODE_STOPPED ("node-stopped");
private final String eventName;
Event(String eventName) {
this.eventName = eventName;
}
}
private static final Logger LOGGER = LoggerManager.getLogger(Statistics.class);
private static final String PING_URL = "https://service.speedment.com/stats";
public static void report(final InfoComponent info,
final ProjectComponent projects,
final Event event) {<FILL_FUNCTION_BODY>}
private static void sendPostRequest(final String url, String data) {
CompletableFuture.runAsync(() -> {
try {
final HttpURLConnection con = (HttpURLConnection)
new URL(url).openConnection();
con.setRequestMethod("POST");
con.setRequestProperty("Content-Type", "application/json;charset=UTF-8");
con.setUseCaches(false);
con.setAllowUserInteraction(false);
con.setDoOutput(true);
con.connect();
try (final OutputStream out = con.getOutputStream()) {
out.write(data.getBytes(StandardCharsets.UTF_8));
out.flush();
}
int status = getResponseCodeFrom(con);
final String text;
try (final BufferedReader rd = new BufferedReader(
new InputStreamReader(status >= 400
? con.getErrorStream()
: con.getInputStream()))) {
final StringBuilder sb = new StringBuilder();
String line;
while ((line = rd.readLine()) != null) {
sb.append(line);
}
text = sb.toString();
}
LOGGER.debug("Statistics response %d: %s", status, text);
} catch (final IOException ex) {
LOGGER.debug(ex);
}
});
}
private static String computerName() {
final String hostName;
try {
hostName = InetAddress.getLocalHost().getHostName();
if (hostName != null && !hostName.isEmpty()) {
return hostName;
}
} catch (final Exception ex) {
// Ignore exception.
}
return Optional.ofNullable(System.getenv("COMPUTERNAME"))
.orElseGet(() -> Optional.ofNullable(System.getenv("HOSTNAME"))
.orElse("unknown")
);
}
private static int getResponseCodeFrom(final HttpURLConnection conn)
throws IOException {
try {
return conn.getResponseCode();
} catch (final FileNotFoundException ex) {
return 404;
}
}
}
|
requireNonNull(info);
requireNonNull(projects);
requireNonNull(event);
if (TestSettings.isTestMode()) {
return;
}
final Project project = projects.getProject();
final Map<String, Object> ping = new HashMap<>();
ping.put("userId", InternalEmailUtil.getUserId().toString());
ping.put("appId", project.getAppId());
ping.put("eventType", event.eventName);
ping.put("productName", info.getTitle());
ping.put("productVersion", info.getImplementationVersion());
ping.put("databases", project.dbmses()
.map(Dbms::getTypeName)
.distinct()
.collect(toList())
);
ping.put("emailAddress", InternalEmailUtil.getEmail());
ping.put("computerName", HOST_NAME);
ping.put("dateStarted", STARTED);
sendPostRequest(PING_URL, Json.toJson(ping));
| 828
| 263
| 1,091
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-core/src/main/java/com/speedment/runtime/core/util/StreamComposition.java
|
StreamComposition
|
configureAutoCloseStream
|
class StreamComposition {
private StreamComposition() {}
/**
* Creates a lazily concatenated Stream whose elements are are all the
* elements of the streams in sequential order. The resulting Stream is
* ordered if all of the input streams are ordered, and parallel if at least
* one of the input streams are parallel. When a terminating operation is
* called, all the streams are automatically and explicitly closed, whereby
* their close handlers are invoked. AutoClosing is performed in sequential
* order too. If a Stream throws an Exception, it is still guaranteed that
* all Streams' close methods are called.
*
* <p>
* Streams are processed one at at time. When one is exhausted, a new one
* will start. Parallelism is only supported within the individual streams
* provided.
* <p>
* N.B. a stream's close method may be called even through that stream never
* produced any output, if a preceding stream threw an Exception.
* <p>
* N.B. an UnsupportedOperationException will be thrown if the concatenated
* stream's {@link Stream#iterator()
* } or {@link Stream#spliterator() } methods are called, because they could
* potentially violate the resulting Stream's AutoClose property.
* <p>
* N.B. Use caution when constructing streams from repeated concatenation.
* Accessing an element of a deeply concatenated stream can result in deep
* call chains, or even {@code StackOverflowException}.
*
* @param <T> The type of stream elements
* @param streams to concatenate
* @return the concatenation of the input streams
* @throws UnsupportedOperationException if the concatenated stream's {@link Stream#iterator()
* } or {@link Stream#spliterator() } methods are called, because they could
* potentially violate the resulting Stream's AutoClose property.
*/
@SuppressWarnings("varargs")
@SafeVarargs // Creating a Stream of an array is safe.
public static <T> Stream<T> concatAndAutoClose(Stream<T>... streams) {
requireNonNullElements(streams);
return configureAutoCloseStream(AutoClosingStream.of(Stream.of(streams).flatMap(Function.identity())), streams);
}
@SuppressWarnings("varargs")
@SafeVarargs // Creating a Stream of an array is safe.
private static <T extends BaseStream<?, ?>> T configureAutoCloseStream(T concatStream, T... streams) {<FILL_FUNCTION_BODY>}
/**
* Creates a concatenated Stream whose elements are are all the
* elements of the streams in sequential order. The resulting Stream is
* ordered if all of the input streams are ordered, and parallel if at least
* one of the input streams are parallel.
*
* <p>
* Streams are processed one at at time. When one is exhausted, a new one
* will start. Parallelism is only supported within the individual streams
* provided.
* <p>
* N.B. Use caution when constructing streams from repeated concatenation.
* Accessing an element of a deeply concatenated stream can result in deep
* call chains, or even {@code StackOverflowException}.
*
* @param <T> The type of stream elements
* @param streams to concatenate
* @return the concatenation of the input streams
*/
@SuppressWarnings("varargs")
@SafeVarargs // Creating a Stream of an array is safe.
public static <T> Stream<T> concat(Stream<T>... streams) {
requireNonNullElements(streams);
return Stream.of(streams).flatMap(Function.identity());
}
}
|
@SuppressWarnings("rawtypes")
final boolean parallel = Stream.of(streams).anyMatch(BaseStream::isParallel); // T:::isParallel gives IDE warning
if (parallel) {
concatStream.parallel();
}
concatStream.onClose(() -> composedClose(streams));
return concatStream;
| 934
| 90
| 1,024
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/ByteFieldImpl.java
|
ByteFieldImpl
|
tableAlias
|
class ByteFieldImpl<ENTITY, D> implements ByteField<ENTITY, D> {
private final ColumnIdentifier<ENTITY> identifier;
private final GetByte<ENTITY, D> getter;
private final ByteSetter<ENTITY> setter;
private final TypeMapper<D, Byte> typeMapper;
private final boolean unique;
private final String tableAlias;
public ByteFieldImpl(
ColumnIdentifier<ENTITY> identifier,
ByteGetter<ENTITY> getter,
ByteSetter<ENTITY> setter,
TypeMapper<D, Byte> typeMapper,
boolean unique) {
this.identifier = requireNonNull(identifier);
this.getter = new GetByteImpl<>(this, getter);
this.setter = requireNonNull(setter);
this.typeMapper = requireNonNull(typeMapper);
this.unique = unique;
this.tableAlias = identifier.getTableId();
}
private ByteFieldImpl(
ColumnIdentifier<ENTITY> identifier,
ByteGetter<ENTITY> getter,
ByteSetter<ENTITY> setter,
TypeMapper<D, Byte> typeMapper,
boolean unique,
String tableAlias) {
this.identifier = requireNonNull(identifier);
this.getter = new GetByteImpl<>(this, getter);
this.setter = requireNonNull(setter);
this.typeMapper = requireNonNull(typeMapper);
this.unique = unique;
this.tableAlias = requireNonNull(tableAlias);
}
@Override
public ColumnIdentifier<ENTITY> identifier() {
return identifier;
}
@Override
public ByteSetter<ENTITY> setter() {
return setter;
}
@Override
public GetByte<ENTITY, D> getter() {
return getter;
}
@Override
public TypeMapper<D, Byte> typeMapper() {
return typeMapper;
}
@Override
public boolean isUnique() {
return unique;
}
@Override
public String tableAlias() {
return tableAlias;
}
@Override
public ByteField<ENTITY, D> tableAlias(String tableAlias) {<FILL_FUNCTION_BODY>}
@Override
public ByteFieldComparator<ENTITY, D> comparator() {
return new ByteFieldComparatorImpl<>(this);
}
@Override
public ByteFieldComparator<ENTITY, D> reversed() {
return comparator().reversed();
}
@Override
public ByteFieldComparator<ENTITY, D> comparatorNullFieldsFirst() {
return comparator();
}
@Override
public NullOrder getNullOrder() {
return NullOrder.LAST;
}
@Override
public boolean isReversed() {
return false;
}
@Override
public FieldPredicate<ENTITY> equal(Byte value) {
return new ByteEqualPredicate<>(this, value);
}
@Override
public FieldPredicate<ENTITY> greaterThan(Byte value) {
return new ByteGreaterThanPredicate<>(this, value);
}
@Override
public FieldPredicate<ENTITY> greaterOrEqual(Byte value) {
return new ByteGreaterOrEqualPredicate<>(this, value);
}
@Override
public FieldPredicate<ENTITY> between(
Byte start,
Byte end,
Inclusion inclusion) {
return new ByteBetweenPredicate<>(this, start, end, inclusion);
}
@Override
public FieldPredicate<ENTITY> in(Collection<Byte> values) {
return new ByteInPredicate<>(this, collectionToSet(values));
}
@Override
public SpeedmentPredicate<ENTITY> notEqual(Byte value) {
return new ByteNotEqualPredicate<>(this, value);
}
@Override
public SpeedmentPredicate<ENTITY> lessOrEqual(Byte value) {
return new ByteLessOrEqualPredicate<>(this, value);
}
@Override
public SpeedmentPredicate<ENTITY> lessThan(Byte value) {
return new ByteLessThanPredicate<>(this, value);
}
@Override
public SpeedmentPredicate<ENTITY> notBetween(
Byte start,
Byte end,
Inclusion inclusion) {
return new ByteNotBetweenPredicate<>(this, start, end, inclusion);
}
@Override
public SpeedmentPredicate<ENTITY> notIn(Collection<Byte> values) {
return new ByteNotInPredicate<>(this, collectionToSet(values));
}
}
|
requireNonNull(tableAlias);
return new ByteFieldImpl<>(identifier, getter, setter, typeMapper, unique, tableAlias);
| 1,238
| 39
| 1,277
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/DoubleForeignKeyFieldImpl.java
|
DoubleForeignKeyFieldImpl
|
tableAlias
|
class DoubleForeignKeyFieldImpl<ENTITY, D, FK_ENTITY> implements DoubleField<ENTITY, D>, DoubleForeignKeyField<ENTITY, D, FK_ENTITY> {
private final ColumnIdentifier<ENTITY> identifier;
private final GetDouble<ENTITY, D> getter;
private final DoubleSetter<ENTITY> setter;
private final DoubleField<FK_ENTITY, D> referenced;
private final TypeMapper<D, Double> typeMapper;
private final boolean unique;
private final String tableAlias;
public DoubleForeignKeyFieldImpl(
ColumnIdentifier<ENTITY> identifier,
DoubleGetter<ENTITY> getter,
DoubleSetter<ENTITY> setter,
DoubleField<FK_ENTITY, D> referenced,
TypeMapper<D, Double> typeMapper,
boolean unique) {
this.identifier = requireNonNull(identifier);
this.getter = new GetDoubleImpl<>(this, getter);
this.setter = requireNonNull(setter);
this.referenced = requireNonNull(referenced);
this.typeMapper = requireNonNull(typeMapper);
this.unique = unique;
this.tableAlias = identifier.getTableId();
}
private DoubleForeignKeyFieldImpl(
ColumnIdentifier<ENTITY> identifier,
DoubleGetter<ENTITY> getter,
DoubleSetter<ENTITY> setter,
DoubleField<FK_ENTITY, D> referenced,
TypeMapper<D, Double> typeMapper,
boolean unique,
String tableAlias) {
this.identifier = requireNonNull(identifier);
this.getter = new GetDoubleImpl<>(this, getter);
this.setter = requireNonNull(setter);
this.referenced = requireNonNull(referenced);
this.typeMapper = requireNonNull(typeMapper);
this.unique = unique;
this.tableAlias = requireNonNull(tableAlias);
}
@Override
public ColumnIdentifier<ENTITY> identifier() {
return identifier;
}
@Override
public DoubleSetter<ENTITY> setter() {
return setter;
}
@Override
public GetDouble<ENTITY, D> getter() {
return getter;
}
@Override
public DoubleField<FK_ENTITY, D> getReferencedField() {
return referenced;
}
@Override
public BackwardFinder<FK_ENTITY, ENTITY> backwardFinder(TableIdentifier<ENTITY> identifier, Supplier<Stream<ENTITY>> streamSupplier) {
return new BackwardFinderImpl<>(this, identifier, streamSupplier);
}
@Override
public FindFrom<ENTITY, FK_ENTITY> finder(TableIdentifier<FK_ENTITY> identifier, Supplier<Stream<FK_ENTITY>> streamSupplier) {
return new FindFromDouble<>(this, referenced, identifier, streamSupplier);
}
@Override
public TypeMapper<D, Double> typeMapper() {
return typeMapper;
}
@Override
public boolean isUnique() {
return unique;
}
@Override
public String tableAlias() {
return tableAlias;
}
@Override
public DoubleFieldComparator<ENTITY, D> comparator() {
return new DoubleFieldComparatorImpl<>(this);
}
@Override
public DoubleFieldComparator<ENTITY, D> reversed() {
return comparator().reversed();
}
@Override
public DoubleFieldComparator<ENTITY, D> comparatorNullFieldsFirst() {
return comparator();
}
@Override
public NullOrder getNullOrder() {
return NullOrder.LAST;
}
@Override
public boolean isReversed() {
return false;
}
@Override
public FieldPredicate<ENTITY> equal(Double value) {
return new DoubleEqualPredicate<>(this, value);
}
@Override
public FieldPredicate<ENTITY> greaterThan(Double value) {
return new DoubleGreaterThanPredicate<>(this, value);
}
@Override
public FieldPredicate<ENTITY> greaterOrEqual(Double value) {
return new DoubleGreaterOrEqualPredicate<>(this, value);
}
@Override
public FieldPredicate<ENTITY> between(
Double start,
Double end,
Inclusion inclusion) {
return new DoubleBetweenPredicate<>(this, start, end, inclusion);
}
@Override
public FieldPredicate<ENTITY> in(Collection<Double> values) {
return new DoubleInPredicate<>(this, collectionToSet(values));
}
@Override
public SpeedmentPredicate<ENTITY> notEqual(Double value) {
return new DoubleNotEqualPredicate<>(this, value);
}
@Override
public SpeedmentPredicate<ENTITY> lessOrEqual(Double value) {
return new DoubleLessOrEqualPredicate<>(this, value);
}
@Override
public SpeedmentPredicate<ENTITY> lessThan(Double value) {
return new DoubleLessThanPredicate<>(this, value);
}
@Override
public SpeedmentPredicate<ENTITY> notBetween(
Double start,
Double end,
Inclusion inclusion) {
return new DoubleNotBetweenPredicate<>(this, start, end, inclusion);
}
@Override
public SpeedmentPredicate<ENTITY> notIn(Collection<Double> values) {
return new DoubleNotInPredicate<>(this, collectionToSet(values));
}
@Override
public DoubleForeignKeyField<ENTITY, D, FK_ENTITY> tableAlias(String tableAlias) {<FILL_FUNCTION_BODY>}
}
|
requireNonNull(tableAlias);
return new DoubleForeignKeyFieldImpl<>(identifier, getter, setter, referenced, typeMapper, unique, tableAlias);
| 1,538
| 44
| 1,582
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/FloatFieldImpl.java
|
FloatFieldImpl
|
tableAlias
|
class FloatFieldImpl<ENTITY, D> implements FloatField<ENTITY, D> {
private final ColumnIdentifier<ENTITY> identifier;
private final GetFloat<ENTITY, D> getter;
private final FloatSetter<ENTITY> setter;
private final TypeMapper<D, Float> typeMapper;
private final boolean unique;
private final String tableAlias;
public FloatFieldImpl(
ColumnIdentifier<ENTITY> identifier,
FloatGetter<ENTITY> getter,
FloatSetter<ENTITY> setter,
TypeMapper<D, Float> typeMapper,
boolean unique) {
this.identifier = requireNonNull(identifier);
this.getter = new GetFloatImpl<>(this, getter);
this.setter = requireNonNull(setter);
this.typeMapper = requireNonNull(typeMapper);
this.unique = unique;
this.tableAlias = identifier.getTableId();
}
private FloatFieldImpl(
ColumnIdentifier<ENTITY> identifier,
FloatGetter<ENTITY> getter,
FloatSetter<ENTITY> setter,
TypeMapper<D, Float> typeMapper,
boolean unique,
String tableAlias) {
this.identifier = requireNonNull(identifier);
this.getter = new GetFloatImpl<>(this, getter);
this.setter = requireNonNull(setter);
this.typeMapper = requireNonNull(typeMapper);
this.unique = unique;
this.tableAlias = requireNonNull(tableAlias);
}
@Override
public ColumnIdentifier<ENTITY> identifier() {
return identifier;
}
@Override
public FloatSetter<ENTITY> setter() {
return setter;
}
@Override
public GetFloat<ENTITY, D> getter() {
return getter;
}
@Override
public TypeMapper<D, Float> typeMapper() {
return typeMapper;
}
@Override
public boolean isUnique() {
return unique;
}
@Override
public String tableAlias() {
return tableAlias;
}
@Override
public FloatField<ENTITY, D> tableAlias(String tableAlias) {<FILL_FUNCTION_BODY>}
@Override
public FloatFieldComparator<ENTITY, D> comparator() {
return new FloatFieldComparatorImpl<>(this);
}
@Override
public FloatFieldComparator<ENTITY, D> reversed() {
return comparator().reversed();
}
@Override
public FloatFieldComparator<ENTITY, D> comparatorNullFieldsFirst() {
return comparator();
}
@Override
public NullOrder getNullOrder() {
return NullOrder.LAST;
}
@Override
public boolean isReversed() {
return false;
}
@Override
public FieldPredicate<ENTITY> equal(Float value) {
return new FloatEqualPredicate<>(this, value);
}
@Override
public FieldPredicate<ENTITY> greaterThan(Float value) {
return new FloatGreaterThanPredicate<>(this, value);
}
@Override
public FieldPredicate<ENTITY> greaterOrEqual(Float value) {
return new FloatGreaterOrEqualPredicate<>(this, value);
}
@Override
public FieldPredicate<ENTITY> between(
Float start,
Float end,
Inclusion inclusion) {
return new FloatBetweenPredicate<>(this, start, end, inclusion);
}
@Override
public FieldPredicate<ENTITY> in(Collection<Float> values) {
return new FloatInPredicate<>(this, collectionToSet(values));
}
@Override
public SpeedmentPredicate<ENTITY> notEqual(Float value) {
return new FloatNotEqualPredicate<>(this, value);
}
@Override
public SpeedmentPredicate<ENTITY> lessOrEqual(Float value) {
return new FloatLessOrEqualPredicate<>(this, value);
}
@Override
public SpeedmentPredicate<ENTITY> lessThan(Float value) {
return new FloatLessThanPredicate<>(this, value);
}
@Override
public SpeedmentPredicate<ENTITY> notBetween(
Float start,
Float end,
Inclusion inclusion) {
return new FloatNotBetweenPredicate<>(this, start, end, inclusion);
}
@Override
public SpeedmentPredicate<ENTITY> notIn(Collection<Float> values) {
return new FloatNotInPredicate<>(this, collectionToSet(values));
}
}
|
requireNonNull(tableAlias);
return new FloatFieldImpl<>(identifier, getter, setter, typeMapper, unique, tableAlias);
| 1,271
| 40
| 1,311
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/FloatForeignKeyFieldImpl.java
|
FloatForeignKeyFieldImpl
|
tableAlias
|
class FloatForeignKeyFieldImpl<ENTITY, D, FK_ENTITY> implements FloatField<ENTITY, D>, FloatForeignKeyField<ENTITY, D, FK_ENTITY> {
private final ColumnIdentifier<ENTITY> identifier;
private final GetFloat<ENTITY, D> getter;
private final FloatSetter<ENTITY> setter;
private final FloatField<FK_ENTITY, D> referenced;
private final TypeMapper<D, Float> typeMapper;
private final boolean unique;
private final String tableAlias;
public FloatForeignKeyFieldImpl(
ColumnIdentifier<ENTITY> identifier,
FloatGetter<ENTITY> getter,
FloatSetter<ENTITY> setter,
FloatField<FK_ENTITY, D> referenced,
TypeMapper<D, Float> typeMapper,
boolean unique) {
this.identifier = requireNonNull(identifier);
this.getter = new GetFloatImpl<>(this, getter);
this.setter = requireNonNull(setter);
this.referenced = requireNonNull(referenced);
this.typeMapper = requireNonNull(typeMapper);
this.unique = unique;
this.tableAlias = identifier.getTableId();
}
private FloatForeignKeyFieldImpl(
ColumnIdentifier<ENTITY> identifier,
FloatGetter<ENTITY> getter,
FloatSetter<ENTITY> setter,
FloatField<FK_ENTITY, D> referenced,
TypeMapper<D, Float> typeMapper,
boolean unique,
String tableAlias) {
this.identifier = requireNonNull(identifier);
this.getter = new GetFloatImpl<>(this, getter);
this.setter = requireNonNull(setter);
this.referenced = requireNonNull(referenced);
this.typeMapper = requireNonNull(typeMapper);
this.unique = unique;
this.tableAlias = requireNonNull(tableAlias);
}
@Override
public ColumnIdentifier<ENTITY> identifier() {
return identifier;
}
@Override
public FloatSetter<ENTITY> setter() {
return setter;
}
@Override
public GetFloat<ENTITY, D> getter() {
return getter;
}
@Override
public FloatField<FK_ENTITY, D> getReferencedField() {
return referenced;
}
@Override
public BackwardFinder<FK_ENTITY, ENTITY> backwardFinder(TableIdentifier<ENTITY> identifier, Supplier<Stream<ENTITY>> streamSupplier) {
return new BackwardFinderImpl<>(this, identifier, streamSupplier);
}
@Override
public FindFrom<ENTITY, FK_ENTITY> finder(TableIdentifier<FK_ENTITY> identifier, Supplier<Stream<FK_ENTITY>> streamSupplier) {
return new FindFromFloat<>(this, referenced, identifier, streamSupplier);
}
@Override
public TypeMapper<D, Float> typeMapper() {
return typeMapper;
}
@Override
public boolean isUnique() {
return unique;
}
@Override
public String tableAlias() {
return tableAlias;
}
@Override
public FloatFieldComparator<ENTITY, D> comparator() {
return new FloatFieldComparatorImpl<>(this);
}
@Override
public FloatFieldComparator<ENTITY, D> reversed() {
return comparator().reversed();
}
@Override
public FloatFieldComparator<ENTITY, D> comparatorNullFieldsFirst() {
return comparator();
}
@Override
public NullOrder getNullOrder() {
return NullOrder.LAST;
}
@Override
public boolean isReversed() {
return false;
}
@Override
public FieldPredicate<ENTITY> equal(Float value) {
return new FloatEqualPredicate<>(this, value);
}
@Override
public FieldPredicate<ENTITY> greaterThan(Float value) {
return new FloatGreaterThanPredicate<>(this, value);
}
@Override
public FieldPredicate<ENTITY> greaterOrEqual(Float value) {
return new FloatGreaterOrEqualPredicate<>(this, value);
}
@Override
public FieldPredicate<ENTITY> between(
Float start,
Float end,
Inclusion inclusion) {
return new FloatBetweenPredicate<>(this, start, end, inclusion);
}
@Override
public FieldPredicate<ENTITY> in(Collection<Float> values) {
return new FloatInPredicate<>(this, collectionToSet(values));
}
@Override
public SpeedmentPredicate<ENTITY> notEqual(Float value) {
return new FloatNotEqualPredicate<>(this, value);
}
@Override
public SpeedmentPredicate<ENTITY> lessOrEqual(Float value) {
return new FloatLessOrEqualPredicate<>(this, value);
}
@Override
public SpeedmentPredicate<ENTITY> lessThan(Float value) {
return new FloatLessThanPredicate<>(this, value);
}
@Override
public SpeedmentPredicate<ENTITY> notBetween(
Float start,
Float end,
Inclusion inclusion) {
return new FloatNotBetweenPredicate<>(this, start, end, inclusion);
}
@Override
public SpeedmentPredicate<ENTITY> notIn(Collection<Float> values) {
return new FloatNotInPredicate<>(this, collectionToSet(values));
}
@Override
public FloatForeignKeyField<ENTITY, D, FK_ENTITY> tableAlias(String tableAlias) {<FILL_FUNCTION_BODY>}
}
|
requireNonNull(tableAlias);
return new FloatForeignKeyFieldImpl<>(identifier, getter, setter, referenced, typeMapper, unique, tableAlias);
| 1,576
| 45
| 1,621
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/IntForeignKeyFieldImpl.java
|
IntForeignKeyFieldImpl
|
tableAlias
|
class IntForeignKeyFieldImpl<ENTITY, D, FK_ENTITY> implements IntField<ENTITY, D>, IntForeignKeyField<ENTITY, D, FK_ENTITY> {
private final ColumnIdentifier<ENTITY> identifier;
private final GetInt<ENTITY, D> getter;
private final IntSetter<ENTITY> setter;
private final IntField<FK_ENTITY, D> referenced;
private final TypeMapper<D, Integer> typeMapper;
private final boolean unique;
private final String tableAlias;
public IntForeignKeyFieldImpl(
ColumnIdentifier<ENTITY> identifier,
IntGetter<ENTITY> getter,
IntSetter<ENTITY> setter,
IntField<FK_ENTITY, D> referenced,
TypeMapper<D, Integer> typeMapper,
boolean unique) {
this.identifier = requireNonNull(identifier);
this.getter = new GetIntImpl<>(this, getter);
this.setter = requireNonNull(setter);
this.referenced = requireNonNull(referenced);
this.typeMapper = requireNonNull(typeMapper);
this.unique = unique;
this.tableAlias = identifier.getTableId();
}
private IntForeignKeyFieldImpl(
ColumnIdentifier<ENTITY> identifier,
IntGetter<ENTITY> getter,
IntSetter<ENTITY> setter,
IntField<FK_ENTITY, D> referenced,
TypeMapper<D, Integer> typeMapper,
boolean unique,
String tableAlias) {
this.identifier = requireNonNull(identifier);
this.getter = new GetIntImpl<>(this, getter);
this.setter = requireNonNull(setter);
this.referenced = requireNonNull(referenced);
this.typeMapper = requireNonNull(typeMapper);
this.unique = unique;
this.tableAlias = requireNonNull(tableAlias);
}
@Override
public ColumnIdentifier<ENTITY> identifier() {
return identifier;
}
@Override
public IntSetter<ENTITY> setter() {
return setter;
}
@Override
public GetInt<ENTITY, D> getter() {
return getter;
}
@Override
public IntField<FK_ENTITY, D> getReferencedField() {
return referenced;
}
@Override
public BackwardFinder<FK_ENTITY, ENTITY> backwardFinder(TableIdentifier<ENTITY> identifier, Supplier<Stream<ENTITY>> streamSupplier) {
return new BackwardFinderImpl<>(this, identifier, streamSupplier);
}
@Override
public FindFrom<ENTITY, FK_ENTITY> finder(TableIdentifier<FK_ENTITY> identifier, Supplier<Stream<FK_ENTITY>> streamSupplier) {
return new FindFromInt<>(this, referenced, identifier, streamSupplier);
}
@Override
public TypeMapper<D, Integer> typeMapper() {
return typeMapper;
}
@Override
public boolean isUnique() {
return unique;
}
@Override
public String tableAlias() {
return tableAlias;
}
@Override
public IntFieldComparator<ENTITY, D> comparator() {
return new IntFieldComparatorImpl<>(this);
}
@Override
public IntFieldComparator<ENTITY, D> reversed() {
return comparator().reversed();
}
@Override
public IntFieldComparator<ENTITY, D> comparatorNullFieldsFirst() {
return comparator();
}
@Override
public NullOrder getNullOrder() {
return NullOrder.LAST;
}
@Override
public boolean isReversed() {
return false;
}
@Override
public FieldPredicate<ENTITY> equal(Integer value) {
return new IntEqualPredicate<>(this, value);
}
@Override
public FieldPredicate<ENTITY> greaterThan(Integer value) {
return new IntGreaterThanPredicate<>(this, value);
}
@Override
public FieldPredicate<ENTITY> greaterOrEqual(Integer value) {
return new IntGreaterOrEqualPredicate<>(this, value);
}
@Override
public FieldPredicate<ENTITY> between(
Integer start,
Integer end,
Inclusion inclusion) {
return new IntBetweenPredicate<>(this, start, end, inclusion);
}
@Override
public FieldPredicate<ENTITY> in(Collection<Integer> values) {
return new IntInPredicate<>(this, collectionToSet(values));
}
@Override
public SpeedmentPredicate<ENTITY> notEqual(Integer value) {
return new IntNotEqualPredicate<>(this, value);
}
@Override
public SpeedmentPredicate<ENTITY> lessOrEqual(Integer value) {
return new IntLessOrEqualPredicate<>(this, value);
}
@Override
public SpeedmentPredicate<ENTITY> lessThan(Integer value) {
return new IntLessThanPredicate<>(this, value);
}
@Override
public SpeedmentPredicate<ENTITY> notBetween(
Integer start,
Integer end,
Inclusion inclusion) {
return new IntNotBetweenPredicate<>(this, start, end, inclusion);
}
@Override
public SpeedmentPredicate<ENTITY> notIn(Collection<Integer> values) {
return new IntNotInPredicate<>(this, collectionToSet(values));
}
@Override
public IntForeignKeyField<ENTITY, D, FK_ENTITY> tableAlias(String tableAlias) {<FILL_FUNCTION_BODY>}
}
|
requireNonNull(tableAlias);
return new IntForeignKeyFieldImpl<>(identifier, getter, setter, referenced, typeMapper, unique, tableAlias);
| 1,538
| 44
| 1,582
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/LongFieldImpl.java
|
LongFieldImpl
|
tableAlias
|
class LongFieldImpl<ENTITY, D> implements LongField<ENTITY, D> {
private final ColumnIdentifier<ENTITY> identifier;
private final GetLong<ENTITY, D> getter;
private final LongSetter<ENTITY> setter;
private final TypeMapper<D, Long> typeMapper;
private final boolean unique;
private final String tableAlias;
public LongFieldImpl(
ColumnIdentifier<ENTITY> identifier,
LongGetter<ENTITY> getter,
LongSetter<ENTITY> setter,
TypeMapper<D, Long> typeMapper,
boolean unique) {
this.identifier = requireNonNull(identifier);
this.getter = new GetLongImpl<>(this, getter);
this.setter = requireNonNull(setter);
this.typeMapper = requireNonNull(typeMapper);
this.unique = unique;
this.tableAlias = identifier.getTableId();
}
private LongFieldImpl(
ColumnIdentifier<ENTITY> identifier,
LongGetter<ENTITY> getter,
LongSetter<ENTITY> setter,
TypeMapper<D, Long> typeMapper,
boolean unique,
String tableAlias) {
this.identifier = requireNonNull(identifier);
this.getter = new GetLongImpl<>(this, getter);
this.setter = requireNonNull(setter);
this.typeMapper = requireNonNull(typeMapper);
this.unique = unique;
this.tableAlias = requireNonNull(tableAlias);
}
@Override
public ColumnIdentifier<ENTITY> identifier() {
return identifier;
}
@Override
public LongSetter<ENTITY> setter() {
return setter;
}
@Override
public GetLong<ENTITY, D> getter() {
return getter;
}
@Override
public TypeMapper<D, Long> typeMapper() {
return typeMapper;
}
@Override
public boolean isUnique() {
return unique;
}
@Override
public String tableAlias() {
return tableAlias;
}
@Override
public LongField<ENTITY, D> tableAlias(String tableAlias) {<FILL_FUNCTION_BODY>}
@Override
public LongFieldComparator<ENTITY, D> comparator() {
return new LongFieldComparatorImpl<>(this);
}
@Override
public LongFieldComparator<ENTITY, D> reversed() {
return comparator().reversed();
}
@Override
public LongFieldComparator<ENTITY, D> comparatorNullFieldsFirst() {
return comparator();
}
@Override
public NullOrder getNullOrder() {
return NullOrder.LAST;
}
@Override
public boolean isReversed() {
return false;
}
@Override
public FieldPredicate<ENTITY> equal(Long value) {
return new LongEqualPredicate<>(this, value);
}
@Override
public FieldPredicate<ENTITY> greaterThan(Long value) {
return new LongGreaterThanPredicate<>(this, value);
}
@Override
public FieldPredicate<ENTITY> greaterOrEqual(Long value) {
return new LongGreaterOrEqualPredicate<>(this, value);
}
@Override
public FieldPredicate<ENTITY> between(
Long start,
Long end,
Inclusion inclusion) {
return new LongBetweenPredicate<>(this, start, end, inclusion);
}
@Override
public FieldPredicate<ENTITY> in(Collection<Long> values) {
return new LongInPredicate<>(this, collectionToSet(values));
}
@Override
public SpeedmentPredicate<ENTITY> notEqual(Long value) {
return new LongNotEqualPredicate<>(this, value);
}
@Override
public SpeedmentPredicate<ENTITY> lessOrEqual(Long value) {
return new LongLessOrEqualPredicate<>(this, value);
}
@Override
public SpeedmentPredicate<ENTITY> lessThan(Long value) {
return new LongLessThanPredicate<>(this, value);
}
@Override
public SpeedmentPredicate<ENTITY> notBetween(
Long start,
Long end,
Inclusion inclusion) {
return new LongNotBetweenPredicate<>(this, start, end, inclusion);
}
@Override
public SpeedmentPredicate<ENTITY> notIn(Collection<Long> values) {
return new LongNotInPredicate<>(this, collectionToSet(values));
}
}
|
requireNonNull(tableAlias);
return new LongFieldImpl<>(identifier, getter, setter, typeMapper, unique, tableAlias);
| 1,238
| 39
| 1,277
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/LongForeignKeyFieldImpl.java
|
LongForeignKeyFieldImpl
|
tableAlias
|
class LongForeignKeyFieldImpl<ENTITY, D, FK_ENTITY> implements LongField<ENTITY, D>, LongForeignKeyField<ENTITY, D, FK_ENTITY> {
private final ColumnIdentifier<ENTITY> identifier;
private final GetLong<ENTITY, D> getter;
private final LongSetter<ENTITY> setter;
private final LongField<FK_ENTITY, D> referenced;
private final TypeMapper<D, Long> typeMapper;
private final boolean unique;
private final String tableAlias;
public LongForeignKeyFieldImpl(
ColumnIdentifier<ENTITY> identifier,
LongGetter<ENTITY> getter,
LongSetter<ENTITY> setter,
LongField<FK_ENTITY, D> referenced,
TypeMapper<D, Long> typeMapper,
boolean unique) {
this.identifier = requireNonNull(identifier);
this.getter = new GetLongImpl<>(this, getter);
this.setter = requireNonNull(setter);
this.referenced = requireNonNull(referenced);
this.typeMapper = requireNonNull(typeMapper);
this.unique = unique;
this.tableAlias = identifier.getTableId();
}
private LongForeignKeyFieldImpl(
ColumnIdentifier<ENTITY> identifier,
LongGetter<ENTITY> getter,
LongSetter<ENTITY> setter,
LongField<FK_ENTITY, D> referenced,
TypeMapper<D, Long> typeMapper,
boolean unique,
String tableAlias) {
this.identifier = requireNonNull(identifier);
this.getter = new GetLongImpl<>(this, getter);
this.setter = requireNonNull(setter);
this.referenced = requireNonNull(referenced);
this.typeMapper = requireNonNull(typeMapper);
this.unique = unique;
this.tableAlias = requireNonNull(tableAlias);
}
@Override
public ColumnIdentifier<ENTITY> identifier() {
return identifier;
}
@Override
public LongSetter<ENTITY> setter() {
return setter;
}
@Override
public GetLong<ENTITY, D> getter() {
return getter;
}
@Override
public LongField<FK_ENTITY, D> getReferencedField() {
return referenced;
}
@Override
public BackwardFinder<FK_ENTITY, ENTITY> backwardFinder(TableIdentifier<ENTITY> identifier, Supplier<Stream<ENTITY>> streamSupplier) {
return new BackwardFinderImpl<>(this, identifier, streamSupplier);
}
@Override
public FindFrom<ENTITY, FK_ENTITY> finder(TableIdentifier<FK_ENTITY> identifier, Supplier<Stream<FK_ENTITY>> streamSupplier) {
return new FindFromLong<>(this, referenced, identifier, streamSupplier);
}
@Override
public TypeMapper<D, Long> typeMapper() {
return typeMapper;
}
@Override
public boolean isUnique() {
return unique;
}
@Override
public String tableAlias() {
return tableAlias;
}
@Override
public LongFieldComparator<ENTITY, D> comparator() {
return new LongFieldComparatorImpl<>(this);
}
@Override
public LongFieldComparator<ENTITY, D> reversed() {
return comparator().reversed();
}
@Override
public LongFieldComparator<ENTITY, D> comparatorNullFieldsFirst() {
return comparator();
}
@Override
public NullOrder getNullOrder() {
return NullOrder.LAST;
}
@Override
public boolean isReversed() {
return false;
}
@Override
public FieldPredicate<ENTITY> equal(Long value) {
return new LongEqualPredicate<>(this, value);
}
@Override
public FieldPredicate<ENTITY> greaterThan(Long value) {
return new LongGreaterThanPredicate<>(this, value);
}
@Override
public FieldPredicate<ENTITY> greaterOrEqual(Long value) {
return new LongGreaterOrEqualPredicate<>(this, value);
}
@Override
public FieldPredicate<ENTITY> between(
Long start,
Long end,
Inclusion inclusion) {
return new LongBetweenPredicate<>(this, start, end, inclusion);
}
@Override
public FieldPredicate<ENTITY> in(Collection<Long> values) {
return new LongInPredicate<>(this, collectionToSet(values));
}
@Override
public SpeedmentPredicate<ENTITY> notEqual(Long value) {
return new LongNotEqualPredicate<>(this, value);
}
@Override
public SpeedmentPredicate<ENTITY> lessOrEqual(Long value) {
return new LongLessOrEqualPredicate<>(this, value);
}
@Override
public SpeedmentPredicate<ENTITY> lessThan(Long value) {
return new LongLessThanPredicate<>(this, value);
}
@Override
public SpeedmentPredicate<ENTITY> notBetween(
Long start,
Long end,
Inclusion inclusion) {
return new LongNotBetweenPredicate<>(this, start, end, inclusion);
}
@Override
public SpeedmentPredicate<ENTITY> notIn(Collection<Long> values) {
return new LongNotInPredicate<>(this, collectionToSet(values));
}
@Override
public LongForeignKeyField<ENTITY, D, FK_ENTITY> tableAlias(String tableAlias) {<FILL_FUNCTION_BODY>}
}
|
requireNonNull(tableAlias);
return new LongForeignKeyFieldImpl<>(identifier, getter, setter, referenced, typeMapper, unique, tableAlias);
| 1,538
| 44
| 1,582
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/ShortFieldImpl.java
|
ShortFieldImpl
|
tableAlias
|
class ShortFieldImpl<ENTITY, D> implements ShortField<ENTITY, D> {
private final ColumnIdentifier<ENTITY> identifier;
private final GetShort<ENTITY, D> getter;
private final ShortSetter<ENTITY> setter;
private final TypeMapper<D, Short> typeMapper;
private final boolean unique;
private final String tableAlias;
public ShortFieldImpl(
ColumnIdentifier<ENTITY> identifier,
ShortGetter<ENTITY> getter,
ShortSetter<ENTITY> setter,
TypeMapper<D, Short> typeMapper,
boolean unique) {
this.identifier = requireNonNull(identifier);
this.getter = new GetShortImpl<>(this, getter);
this.setter = requireNonNull(setter);
this.typeMapper = requireNonNull(typeMapper);
this.unique = unique;
this.tableAlias = identifier.getTableId();
}
private ShortFieldImpl(
ColumnIdentifier<ENTITY> identifier,
ShortGetter<ENTITY> getter,
ShortSetter<ENTITY> setter,
TypeMapper<D, Short> typeMapper,
boolean unique,
String tableAlias) {
this.identifier = requireNonNull(identifier);
this.getter = new GetShortImpl<>(this, getter);
this.setter = requireNonNull(setter);
this.typeMapper = requireNonNull(typeMapper);
this.unique = unique;
this.tableAlias = requireNonNull(tableAlias);
}
@Override
public ColumnIdentifier<ENTITY> identifier() {
return identifier;
}
@Override
public ShortSetter<ENTITY> setter() {
return setter;
}
@Override
public GetShort<ENTITY, D> getter() {
return getter;
}
@Override
public TypeMapper<D, Short> typeMapper() {
return typeMapper;
}
@Override
public boolean isUnique() {
return unique;
}
@Override
public String tableAlias() {
return tableAlias;
}
@Override
public ShortField<ENTITY, D> tableAlias(String tableAlias) {<FILL_FUNCTION_BODY>}
@Override
public ShortFieldComparator<ENTITY, D> comparator() {
return new ShortFieldComparatorImpl<>(this);
}
@Override
public ShortFieldComparator<ENTITY, D> reversed() {
return comparator().reversed();
}
@Override
public ShortFieldComparator<ENTITY, D> comparatorNullFieldsFirst() {
return comparator();
}
@Override
public NullOrder getNullOrder() {
return NullOrder.LAST;
}
@Override
public boolean isReversed() {
return false;
}
@Override
public FieldPredicate<ENTITY> equal(Short value) {
return new ShortEqualPredicate<>(this, value);
}
@Override
public FieldPredicate<ENTITY> greaterThan(Short value) {
return new ShortGreaterThanPredicate<>(this, value);
}
@Override
public FieldPredicate<ENTITY> greaterOrEqual(Short value) {
return new ShortGreaterOrEqualPredicate<>(this, value);
}
@Override
public FieldPredicate<ENTITY> between(
Short start,
Short end,
Inclusion inclusion) {
return new ShortBetweenPredicate<>(this, start, end, inclusion);
}
@Override
public FieldPredicate<ENTITY> in(Collection<Short> values) {
return new ShortInPredicate<>(this, collectionToSet(values));
}
@Override
public SpeedmentPredicate<ENTITY> notEqual(Short value) {
return new ShortNotEqualPredicate<>(this, value);
}
@Override
public SpeedmentPredicate<ENTITY> lessOrEqual(Short value) {
return new ShortLessOrEqualPredicate<>(this, value);
}
@Override
public SpeedmentPredicate<ENTITY> lessThan(Short value) {
return new ShortLessThanPredicate<>(this, value);
}
@Override
public SpeedmentPredicate<ENTITY> notBetween(
Short start,
Short end,
Inclusion inclusion) {
return new ShortNotBetweenPredicate<>(this, start, end, inclusion);
}
@Override
public SpeedmentPredicate<ENTITY> notIn(Collection<Short> values) {
return new ShortNotInPredicate<>(this, collectionToSet(values));
}
}
|
requireNonNull(tableAlias);
return new ShortFieldImpl<>(identifier, getter, setter, typeMapper, unique, tableAlias);
| 1,238
| 39
| 1,277
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/comparator/BooleanFieldComparatorImpl.java
|
BooleanFieldComparatorImpl
|
applyReversed
|
class BooleanFieldComparatorImpl<ENTITY, D>
extends AbstractFieldComparator<ENTITY>
implements BooleanFieldComparator<ENTITY, D> {
private final HasBooleanValue<ENTITY, D> field;
private final boolean reversed;
public BooleanFieldComparatorImpl(HasBooleanValue<ENTITY, D> field) {
this(field, false);
}
BooleanFieldComparatorImpl(HasBooleanValue<ENTITY, D> field, boolean reversed) {
this.field = requireNonNull(field);
this.reversed = reversed;
}
@Override
public HasBooleanValue<ENTITY, D> getField() {
return field;
}
@Override
public NullOrder getNullOrder() {
return NullOrder.NONE;
}
@Override
public boolean isReversed() {
return reversed;
}
@Override
public BooleanFieldComparatorImpl<ENTITY, D> reversed() {
return new BooleanFieldComparatorImpl<>(field, !reversed);
}
@Override
public int compare(ENTITY first, ENTITY second) {
requireNonNulls(first, second);
final boolean a = field.getAsBoolean(first);
final boolean b = field.getAsBoolean(second);
return applyReversed(Boolean.compare(a, b));
}
@Override
public int hashCode() {
return (4049 + Objects.hashCode(this.field.identifier())) * 3109
+ Boolean.hashCode(reversed);
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (!(obj instanceof FieldComparator)) return false;
@SuppressWarnings("unchecked")
final FieldComparator<ENTITY> casted =
(FieldComparator<ENTITY>) obj;
return reversed == casted.isReversed()
&& Objects.equals(
field.identifier(),
casted.getField().identifier()
);
}
@Override
public String toString() {
return "(order by " + field.identifier() + " " +
(reversed ? "descending" : "ascending") + ")";
}
private int applyReversed(int compare) {<FILL_FUNCTION_BODY>}
}
|
if (compare == 0) {
return 0;
} else {
if (reversed) {
if (compare > 0) {
return -1;
} else {
return 1;
}
} else {
if (compare > 0) {
return 1;
} else {
return -1;
}
}
}
| 618
| 101
| 719
|
<methods>public Comparator<ENTITY> thenComparing(Comparator<? super ENTITY>) ,public Comparator<ENTITY> thenComparing(Function<? super ENTITY,? extends U>, Comparator<? super U>) ,public Comparator<ENTITY> thenComparing(Function<? super ENTITY,? extends U>) ,public Comparator<ENTITY> thenComparingDouble(ToDoubleFunction<? super ENTITY>) ,public Comparator<ENTITY> thenComparingInt(ToIntFunction<? super ENTITY>) ,public Comparator<ENTITY> thenComparingLong(ToLongFunction<? super ENTITY>) <variables>
|
speedment_speedment
|
speedment/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/comparator/ByteFieldComparatorImpl.java
|
ByteFieldComparatorImpl
|
compare
|
class ByteFieldComparatorImpl<ENTITY, D>
extends AbstractFieldComparator<ENTITY>
implements ByteFieldComparator<ENTITY, D> {
private final HasByteValue<ENTITY, D> field;
private final boolean reversed;
public ByteFieldComparatorImpl(HasByteValue<ENTITY, D> field) {
this(field, false);
}
ByteFieldComparatorImpl(HasByteValue<ENTITY, D> field, boolean reversed) {
this.field = requireNonNull(field);
this.reversed = reversed;
}
@Override
public HasByteValue<ENTITY, D> getField() {
return field;
}
@Override
public NullOrder getNullOrder() {
return NullOrder.NONE;
}
@Override
public boolean isReversed() {
return reversed;
}
@Override
public ByteFieldComparatorImpl<ENTITY, D> reversed() {
return new ByteFieldComparatorImpl<>(field, !reversed);
}
@Override
public int compare(ENTITY first, ENTITY second) {<FILL_FUNCTION_BODY>}
@Override
public int hashCode() {
return (4049 + Objects.hashCode(this.field.identifier())) * 3109
+ Boolean.hashCode(reversed);
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (!(obj instanceof FieldComparator)) return false;
@SuppressWarnings("unchecked")
final FieldComparator<ENTITY> casted =
(FieldComparator<ENTITY>) obj;
return reversed == casted.isReversed()
&& Objects.equals(
field.identifier(),
casted.getField().identifier()
);
}
@Override
public String toString() {
return "(order by " + field.identifier() + " " +
(reversed ? "descending" : "ascending") + ")";
}
private int applyReversed(int compare) {
if (compare == 0) {
return 0;
} else {
if (reversed) {
if (compare > 0) {
return -1;
} else {
return 1;
}
} else {
if (compare > 0) {
return 1;
} else {
return -1;
}
}
}
}
}
|
requireNonNulls(first, second);
final byte a = field.getAsByte(first);
final byte b = field.getAsByte(second);
return applyReversed(Byte.compare(a, b));
| 675
| 58
| 733
|
<methods>public Comparator<ENTITY> thenComparing(Comparator<? super ENTITY>) ,public Comparator<ENTITY> thenComparing(Function<? super ENTITY,? extends U>, Comparator<? super U>) ,public Comparator<ENTITY> thenComparing(Function<? super ENTITY,? extends U>) ,public Comparator<ENTITY> thenComparingDouble(ToDoubleFunction<? super ENTITY>) ,public Comparator<ENTITY> thenComparingInt(ToIntFunction<? super ENTITY>) ,public Comparator<ENTITY> thenComparingLong(ToLongFunction<? super ENTITY>) <variables>
|
speedment_speedment
|
speedment/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/comparator/CharFieldComparatorImpl.java
|
CharFieldComparatorImpl
|
equals
|
class CharFieldComparatorImpl<ENTITY, D>
extends AbstractFieldComparator<ENTITY>
implements CharFieldComparator<ENTITY, D> {
private final HasCharValue<ENTITY, D> field;
private final boolean reversed;
public CharFieldComparatorImpl(HasCharValue<ENTITY, D> field) {
this(field, false);
}
CharFieldComparatorImpl(HasCharValue<ENTITY, D> field, boolean reversed) {
this.field = requireNonNull(field);
this.reversed = reversed;
}
@Override
public HasCharValue<ENTITY, D> getField() {
return field;
}
@Override
public NullOrder getNullOrder() {
return NullOrder.NONE;
}
@Override
public boolean isReversed() {
return reversed;
}
@Override
public CharFieldComparatorImpl<ENTITY, D> reversed() {
return new CharFieldComparatorImpl<>(field, !reversed);
}
@Override
public int compare(ENTITY first, ENTITY second) {
requireNonNulls(first, second);
final char a = field.getAsChar(first);
final char b = field.getAsChar(second);
return applyReversed(Character.compare(a, b));
}
@Override
public int hashCode() {
return (4049 + Objects.hashCode(this.field.identifier())) * 3109
+ Boolean.hashCode(reversed);
}
@Override
public boolean equals(Object obj) {<FILL_FUNCTION_BODY>}
@Override
public String toString() {
return "(order by " + field.identifier() + " " +
(reversed ? "descending" : "ascending") + ")";
}
private int applyReversed(int compare) {
if (compare == 0) {
return 0;
} else {
if (reversed) {
if (compare > 0) {
return -1;
} else {
return 1;
}
} else {
if (compare > 0) {
return 1;
} else {
return -1;
}
}
}
}
}
|
if (this == obj) return true;
if (!(obj instanceof FieldComparator)) return false;
@SuppressWarnings("unchecked")
final FieldComparator<ENTITY> casted =
(FieldComparator<ENTITY>) obj;
return reversed == casted.isReversed()
&& Objects.equals(
field.identifier(),
casted.getField().identifier()
);
| 619
| 114
| 733
|
<methods>public Comparator<ENTITY> thenComparing(Comparator<? super ENTITY>) ,public Comparator<ENTITY> thenComparing(Function<? super ENTITY,? extends U>, Comparator<? super U>) ,public Comparator<ENTITY> thenComparing(Function<? super ENTITY,? extends U>) ,public Comparator<ENTITY> thenComparingDouble(ToDoubleFunction<? super ENTITY>) ,public Comparator<ENTITY> thenComparingInt(ToIntFunction<? super ENTITY>) ,public Comparator<ENTITY> thenComparingLong(ToLongFunction<? super ENTITY>) <variables>
|
speedment_speedment
|
speedment/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/comparator/DoubleFieldComparatorImpl.java
|
DoubleFieldComparatorImpl
|
equals
|
class DoubleFieldComparatorImpl<ENTITY, D>
extends AbstractFieldComparator<ENTITY>
implements DoubleFieldComparator<ENTITY, D> {
private final HasDoubleValue<ENTITY, D> field;
private final boolean reversed;
public DoubleFieldComparatorImpl(HasDoubleValue<ENTITY, D> field) {
this(field, false);
}
DoubleFieldComparatorImpl(HasDoubleValue<ENTITY, D> field, boolean reversed) {
this.field = requireNonNull(field);
this.reversed = reversed;
}
@Override
public HasDoubleValue<ENTITY, D> getField() {
return field;
}
@Override
public NullOrder getNullOrder() {
return NullOrder.NONE;
}
@Override
public boolean isReversed() {
return reversed;
}
@Override
public DoubleFieldComparatorImpl<ENTITY, D> reversed() {
return new DoubleFieldComparatorImpl<>(field, !reversed);
}
@Override
public int compare(ENTITY first, ENTITY second) {
requireNonNulls(first, second);
final double a = field.getAsDouble(first);
final double b = field.getAsDouble(second);
return applyReversed(Double.compare(a, b));
}
@Override
public int hashCode() {
return (4049 + Objects.hashCode(this.field.identifier())) * 3109
+ Boolean.hashCode(reversed);
}
@Override
public boolean equals(Object obj) {<FILL_FUNCTION_BODY>}
@Override
public String toString() {
return "(order by " + field.identifier() + " " +
(reversed ? "descending" : "ascending") + ")";
}
private int applyReversed(double compare) {
if (compare == 0) {
return 0;
} else {
if (reversed) {
if (compare > 0) {
return -1;
} else {
return 1;
}
} else {
if (compare > 0) {
return 1;
} else {
return -1;
}
}
}
}
}
|
if (this == obj) return true;
if (!(obj instanceof FieldComparator)) return false;
@SuppressWarnings("unchecked")
final FieldComparator<ENTITY> casted =
(FieldComparator<ENTITY>) obj;
return reversed == casted.isReversed()
&& Objects.equals(
field.identifier(),
casted.getField().identifier()
);
| 619
| 114
| 733
|
<methods>public Comparator<ENTITY> thenComparing(Comparator<? super ENTITY>) ,public Comparator<ENTITY> thenComparing(Function<? super ENTITY,? extends U>, Comparator<? super U>) ,public Comparator<ENTITY> thenComparing(Function<? super ENTITY,? extends U>) ,public Comparator<ENTITY> thenComparingDouble(ToDoubleFunction<? super ENTITY>) ,public Comparator<ENTITY> thenComparingInt(ToIntFunction<? super ENTITY>) ,public Comparator<ENTITY> thenComparingLong(ToLongFunction<? super ENTITY>) <variables>
|
speedment_speedment
|
speedment/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/comparator/FloatFieldComparatorImpl.java
|
FloatFieldComparatorImpl
|
compare
|
class FloatFieldComparatorImpl<ENTITY, D>
extends AbstractFieldComparator<ENTITY>
implements FloatFieldComparator<ENTITY, D> {
private final HasFloatValue<ENTITY, D> field;
private final boolean reversed;
public FloatFieldComparatorImpl(HasFloatValue<ENTITY, D> field) {
this(field, false);
}
FloatFieldComparatorImpl(HasFloatValue<ENTITY, D> field, boolean reversed) {
this.field = requireNonNull(field);
this.reversed = reversed;
}
@Override
public HasFloatValue<ENTITY, D> getField() {
return field;
}
@Override
public NullOrder getNullOrder() {
return NullOrder.NONE;
}
@Override
public boolean isReversed() {
return reversed;
}
@Override
public FloatFieldComparatorImpl<ENTITY, D> reversed() {
return new FloatFieldComparatorImpl<>(field, !reversed);
}
@Override
public int compare(ENTITY first, ENTITY second) {<FILL_FUNCTION_BODY>}
@Override
public int hashCode() {
return (4049 + Objects.hashCode(this.field.identifier())) * 3109
+ Boolean.hashCode(reversed);
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (!(obj instanceof FieldComparator)) return false;
@SuppressWarnings("unchecked")
final FieldComparator<ENTITY> casted =
(FieldComparator<ENTITY>) obj;
return reversed == casted.isReversed()
&& Objects.equals(
field.identifier(),
casted.getField().identifier()
);
}
@Override
public String toString() {
return "(order by " + field.identifier() + " " +
(reversed ? "descending" : "ascending") + ")";
}
private int applyReversed(float compare) {
if (compare == 0) {
return 0;
} else {
if (reversed) {
if (compare > 0) {
return -1;
} else {
return 1;
}
} else {
if (compare > 0) {
return 1;
} else {
return -1;
}
}
}
}
}
|
requireNonNulls(first, second);
final float a = field.getAsFloat(first);
final float b = field.getAsFloat(second);
return applyReversed(Float.compare(a, b));
| 681
| 58
| 739
|
<methods>public Comparator<ENTITY> thenComparing(Comparator<? super ENTITY>) ,public Comparator<ENTITY> thenComparing(Function<? super ENTITY,? extends U>, Comparator<? super U>) ,public Comparator<ENTITY> thenComparing(Function<? super ENTITY,? extends U>) ,public Comparator<ENTITY> thenComparingDouble(ToDoubleFunction<? super ENTITY>) ,public Comparator<ENTITY> thenComparingInt(ToIntFunction<? super ENTITY>) ,public Comparator<ENTITY> thenComparingLong(ToLongFunction<? super ENTITY>) <variables>
|
speedment_speedment
|
speedment/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/comparator/ReferenceFieldComparatorImpl.java
|
ReferenceFieldComparatorImpl
|
equals
|
class ReferenceFieldComparatorImpl
<ENTITY, D, V extends Comparable<? super V>>
extends AbstractFieldComparator<ENTITY>
implements ReferenceFieldComparator<ENTITY, D, V> {
private final ComparableField<ENTITY, D, V> field;
private final NullOrder nullOrder;
private final boolean reversed;
public ReferenceFieldComparatorImpl(
final ComparableField<ENTITY, D, V> field,
final NullOrder nullOrder) {
this(field, nullOrder, false);
}
ReferenceFieldComparatorImpl(
final ComparableField<ENTITY, D, V> field,
final NullOrder nullOrder,
final boolean reversed) {
this.field = requireNonNull(field);
this.nullOrder = requireNonNull(nullOrder);
this.reversed = reversed;
}
@Override
public ComparableField<ENTITY, D, V> getField() {
return field;
}
@Override
public NullOrder getNullOrder() {
return nullOrder;
}
@Override
public boolean isReversed() {
return reversed;
}
@Override
public FieldComparator<ENTITY> reversed() {
return new ReferenceFieldComparatorImpl<>(field, nullOrder, !reversed);
}
@Override
public int compare(ENTITY o1, ENTITY o2) {
final V o1Value = field.get(requireNonNull(o1));
final V o2Value = field.get(requireNonNull(o2));
if (o1Value == null && o2Value == null) {
if (NullOrder.NONE == nullOrder) {
throw new NullPointerException(
"Both fields were null and null fields not allowed"
);
}
return 0;
} else if (o1Value == null) {
return forNull(Parameter.FIRST);
} else if (o2Value == null) {
return forNull(Parameter.SECOND);
}
return applyReversed(o1Value.compareTo(o2Value));
}
@Override
public int hashCode() {
return ((4049 + Objects.hashCode(field.identifier())) * 3109
+ nullOrder.hashCode()) * 1039
+ Boolean.hashCode(reversed);
}
@Override
public boolean equals(Object obj) {<FILL_FUNCTION_BODY>}
@Override
public String toString() {
return "(order by " + field.identifier() + " " +
(reversed ? "descending" : "ascending") + ")";
}
private int forNull(Parameter parameter) {
final int firstOutcome = (Parameter.FIRST == parameter) ? -1 : 1;
final int lastOutcome = -firstOutcome;
switch (nullOrder) {
case FIRST : return applyReversed(firstOutcome);
case LAST : return applyReversed(lastOutcome);
case NONE : throw new NullPointerException(
"A field was null and null fields not allowed"
);
default : throw new IllegalStateException("Illegal NullOrder");
}
}
private int applyReversed(int compare) {
return reversed ? -compare : compare;
}
private enum Parameter {
FIRST, SECOND
}
}
|
if (this == obj) return true;
if (!(obj instanceof FieldComparator)) return false;
@SuppressWarnings("unchecked")
final FieldComparator<ENTITY> casted =
(FieldComparator<ENTITY>) obj;
return reversed == casted.isReversed()
&& nullOrder == casted.getNullOrder()
&& Objects.equals(
field.identifier(),
casted.getField().identifier()
);
| 897
| 128
| 1,025
|
<methods>public Comparator<ENTITY> thenComparing(Comparator<? super ENTITY>) ,public Comparator<ENTITY> thenComparing(Function<? super ENTITY,? extends U>, Comparator<? super U>) ,public Comparator<ENTITY> thenComparing(Function<? super ENTITY,? extends U>) ,public Comparator<ENTITY> thenComparingDouble(ToDoubleFunction<? super ENTITY>) ,public Comparator<ENTITY> thenComparingInt(ToIntFunction<? super ENTITY>) ,public Comparator<ENTITY> thenComparingLong(ToLongFunction<? super ENTITY>) <variables>
|
speedment_speedment
|
speedment/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/comparator/ShortFieldComparatorImpl.java
|
ShortFieldComparatorImpl
|
equals
|
class ShortFieldComparatorImpl<ENTITY, D>
extends AbstractFieldComparator<ENTITY>
implements ShortFieldComparator<ENTITY, D> {
private final HasShortValue<ENTITY, D> field;
private final boolean reversed;
public ShortFieldComparatorImpl(HasShortValue<ENTITY, D> field) {
this(field, false);
}
ShortFieldComparatorImpl(HasShortValue<ENTITY, D> field, boolean reversed) {
this.field = requireNonNull(field);
this.reversed = reversed;
}
@Override
public HasShortValue<ENTITY, D> getField() {
return field;
}
@Override
public NullOrder getNullOrder() {
return NullOrder.NONE;
}
@Override
public boolean isReversed() {
return reversed;
}
@Override
public ShortFieldComparatorImpl<ENTITY, D> reversed() {
return new ShortFieldComparatorImpl<>(field, !reversed);
}
@Override
public int compare(ENTITY first, ENTITY second) {
requireNonNulls(first, second);
final short a = field.getAsShort(first);
final short b = field.getAsShort(second);
return applyReversed(Short.compare(a, b));
}
@Override
public int hashCode() {
return (4049 + Objects.hashCode(this.field.identifier())) * 3109
+ Boolean.hashCode(reversed);
}
@Override
public boolean equals(Object obj) {<FILL_FUNCTION_BODY>}
@Override
public String toString() {
return "(order by " + field.identifier() + " " +
(reversed ? "descending" : "ascending") + ")";
}
private int applyReversed(int compare) {
if (compare == 0) {
return 0;
} else {
if (reversed) {
if (compare > 0) {
return -1;
} else {
return 1;
}
} else {
if (compare > 0) {
return 1;
} else {
return -1;
}
}
}
}
}
|
if (this == obj) return true;
if (!(obj instanceof FieldComparator)) return false;
@SuppressWarnings("unchecked")
final FieldComparator<ENTITY> casted =
(FieldComparator<ENTITY>) obj;
return reversed == casted.isReversed()
&& Objects.equals(
field.identifier(),
casted.getField().identifier()
);
| 619
| 114
| 733
|
<methods>public Comparator<ENTITY> thenComparing(Comparator<? super ENTITY>) ,public Comparator<ENTITY> thenComparing(Function<? super ENTITY,? extends U>, Comparator<? super U>) ,public Comparator<ENTITY> thenComparing(Function<? super ENTITY,? extends U>) ,public Comparator<ENTITY> thenComparingDouble(ToDoubleFunction<? super ENTITY>) ,public Comparator<ENTITY> thenComparingInt(ToIntFunction<? super ENTITY>) ,public Comparator<ENTITY> thenComparingLong(ToLongFunction<? super ENTITY>) <variables>
|
speedment_speedment
|
speedment/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/expression/FieldToBigDecimalImpl.java
|
FieldToBigDecimalImpl
|
apply
|
class FieldToBigDecimalImpl<ENTITY, V>
extends AbstractFieldMapper<ENTITY, V, BigDecimal, ToBigDecimal<ENTITY>, Function<V, BigDecimal>>
implements FieldToBigDecimal<ENTITY, V> {
public FieldToBigDecimalImpl(ReferenceField<ENTITY, ?, V> field,
Function<V, BigDecimal> mapper) {
super(field, mapper);
}
@Override
public BigDecimal apply(ENTITY entity) {<FILL_FUNCTION_BODY>}
}
|
final V value = field.get(entity);
if (value == null) return null;
else return mapper.apply(value);
| 143
| 37
| 180
|
<methods>public ReferenceField<ENTITY,?,V> getField() ,public Function<V,java.math.BigDecimal> getMapper() ,public FieldIsNotNullPredicate<ENTITY,java.math.BigDecimal> isNotNull() ,public FieldIsNullPredicate<ENTITY,java.math.BigDecimal> isNull() <variables>final non-sealed ReferenceField<ENTITY,?,V> field,final non-sealed Function<V,java.math.BigDecimal> mapper
|
speedment_speedment
|
speedment/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/expression/FieldToBooleanImpl.java
|
FieldToBooleanImpl
|
apply
|
class FieldToBooleanImpl<ENTITY, V>
extends AbstractFieldMapper<ENTITY, V, Boolean, ToBoolean<ENTITY>, ToBooleanFunction<V>>
implements FieldToBoolean<ENTITY, V> {
public FieldToBooleanImpl(
final ReferenceField<ENTITY, ?, V> field,
final ToBooleanFunction<V> mapper
) {
super(field, mapper);
}
@Override
public Boolean apply(ENTITY entity) {<FILL_FUNCTION_BODY>}
@Override
public boolean applyAsBoolean(ENTITY object) {
return mapper.applyAsBoolean(field.get(object));
}
}
|
final V value = field.get(entity);
if (value == null) return null;
else return mapper.applyAsBoolean(value);
| 170
| 39
| 209
|
<methods>public ReferenceField<ENTITY,?,V> getField() ,public ToBooleanFunction<V> getMapper() ,public FieldIsNotNullPredicate<ENTITY,java.lang.Boolean> isNotNull() ,public FieldIsNullPredicate<ENTITY,java.lang.Boolean> isNull() <variables>final non-sealed ReferenceField<ENTITY,?,V> field,final non-sealed ToBooleanFunction<V> mapper
|
speedment_speedment
|
speedment/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/expression/FieldToByteImpl.java
|
FieldToByteImpl
|
apply
|
class FieldToByteImpl<ENTITY, V>
extends AbstractFieldMapper<ENTITY, V, Byte, ToByte<ENTITY>, ToByteFunction<V>>
implements FieldToByte<ENTITY, V> {
public FieldToByteImpl(ReferenceField<ENTITY, ?, V> field,
ToByteFunction<V> mapper) {
super(field, mapper);
}
@Override
public Byte apply(ENTITY entity) {<FILL_FUNCTION_BODY>}
@Override
public byte applyAsByte(ENTITY object) {
return mapper.applyAsByte(field.get(object));
}
}
|
final V value = field.get(entity);
if (value == null) return null;
else return mapper.applyAsByte(value);
| 164
| 39
| 203
|
<methods>public ReferenceField<ENTITY,?,V> getField() ,public ToByteFunction<V> getMapper() ,public FieldIsNotNullPredicate<ENTITY,java.lang.Byte> isNotNull() ,public FieldIsNullPredicate<ENTITY,java.lang.Byte> isNull() <variables>final non-sealed ReferenceField<ENTITY,?,V> field,final non-sealed ToByteFunction<V> mapper
|
speedment_speedment
|
speedment/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/expression/FieldToCharImpl.java
|
FieldToCharImpl
|
apply
|
class FieldToCharImpl<ENTITY, V>
extends AbstractFieldMapper<ENTITY, V, Character, ToChar<ENTITY>, ToCharFunction<V>>
implements FieldToChar<ENTITY, V> {
public FieldToCharImpl(ReferenceField<ENTITY, ?, V> field,
ToCharFunction<V> mapper) {
super(field, mapper);
}
@Override
public Character apply(ENTITY entity) {<FILL_FUNCTION_BODY>}
@Override
public char applyAsChar(ENTITY object) {
return mapper.applyAsChar(field.get(object));
}
}
|
final V value = field.get(entity);
if (value == null) return null;
else return mapper.applyAsChar(value);
| 164
| 39
| 203
|
<methods>public ReferenceField<ENTITY,?,V> getField() ,public ToCharFunction<V> getMapper() ,public FieldIsNotNullPredicate<ENTITY,java.lang.Character> isNotNull() ,public FieldIsNullPredicate<ENTITY,java.lang.Character> isNull() <variables>final non-sealed ReferenceField<ENTITY,?,V> field,final non-sealed ToCharFunction<V> mapper
|
speedment_speedment
|
speedment/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/expression/FieldToDoubleImpl.java
|
FieldToDoubleImpl
|
apply
|
class FieldToDoubleImpl<ENTITY, V>
extends AbstractFieldMapper<ENTITY, V, Double, ToDouble<ENTITY>, ToDoubleFunction<V>>
implements FieldToDouble<ENTITY, V> {
public FieldToDoubleImpl(ReferenceField<ENTITY, ?, V> field,
ToDoubleFunction<V> mapper) {
super(field, mapper);
}
@Override
public Double apply(ENTITY entity) {<FILL_FUNCTION_BODY>}
@Override
public double applyAsDouble(ENTITY object) {
return mapper.applyAsDouble(field.get(object));
}
}
|
final V value = field.get(entity);
if (value == null) return null;
else return mapper.applyAsDouble(value);
| 164
| 39
| 203
|
<methods>public ReferenceField<ENTITY,?,V> getField() ,public ToDoubleFunction<V> getMapper() ,public FieldIsNotNullPredicate<ENTITY,java.lang.Double> isNotNull() ,public FieldIsNullPredicate<ENTITY,java.lang.Double> isNull() <variables>final non-sealed ReferenceField<ENTITY,?,V> field,final non-sealed ToDoubleFunction<V> mapper
|
speedment_speedment
|
speedment/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/expression/FieldToEnumImpl.java
|
FieldToEnumImpl
|
apply
|
class FieldToEnumImpl<ENTITY, V, E extends Enum<E>>
extends AbstractFieldMapper<ENTITY, V, E, ToEnum<ENTITY, E>, Function<V, E>>
implements FieldToEnum<ENTITY, V, E> {
private final Class<E> enumClass;
public FieldToEnumImpl(ReferenceField<ENTITY, ?, V> field,
Function<V, E> mapper,
Class<E> enumClass) {
super(field, mapper);
this.enumClass = requireNonNull(enumClass);
}
@Override
public Class<E> enumClass() {
return enumClass;
}
@Override
public E apply(ENTITY entity) {<FILL_FUNCTION_BODY>}
}
|
final V value = field.get(entity);
if (value == null) return null;
else return mapper.apply(value);
| 198
| 37
| 235
|
<methods>public ReferenceField<ENTITY,?,V> getField() ,public Function<V,E> getMapper() ,public FieldIsNotNullPredicate<ENTITY,E> isNotNull() ,public FieldIsNullPredicate<ENTITY,E> isNull() <variables>final non-sealed ReferenceField<ENTITY,?,V> field,final non-sealed Function<V,E> mapper
|
speedment_speedment
|
speedment/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/expression/FieldToFloatImpl.java
|
FieldToFloatImpl
|
apply
|
class FieldToFloatImpl<ENTITY, V>
extends AbstractFieldMapper<ENTITY, V, Float, ToFloat<ENTITY>, ToFloatFunction<V>>
implements FieldToFloat<ENTITY, V> {
public FieldToFloatImpl(ReferenceField<ENTITY, ?, V> field,
ToFloatFunction<V> mapper) {
super(field, mapper);
}
@Override
public Float apply(ENTITY entity) {<FILL_FUNCTION_BODY>}
@Override
public float applyAsFloat(ENTITY object) {
return mapper.applyAsFloat(field.get(object));
}
}
|
final V value = field.get(entity);
if (value == null) return null;
else return mapper.applyAsFloat(value);
| 166
| 39
| 205
|
<methods>public ReferenceField<ENTITY,?,V> getField() ,public ToFloatFunction<V> getMapper() ,public FieldIsNotNullPredicate<ENTITY,java.lang.Float> isNotNull() ,public FieldIsNullPredicate<ENTITY,java.lang.Float> isNull() <variables>final non-sealed ReferenceField<ENTITY,?,V> field,final non-sealed ToFloatFunction<V> mapper
|
speedment_speedment
|
speedment/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/expression/FieldToLongImpl.java
|
FieldToLongImpl
|
apply
|
class FieldToLongImpl<ENTITY, V>
extends AbstractFieldMapper<ENTITY, V, Long, ToLong<ENTITY>, ToLongFunction<V>>
implements FieldToLong<ENTITY, V> {
public FieldToLongImpl(ReferenceField<ENTITY, ?, V> field,
ToLongFunction<V> mapper) {
super(field, mapper);
}
@Override
public Long apply(ENTITY entity) {<FILL_FUNCTION_BODY>}
@Override
public long applyAsLong(ENTITY object) {
return mapper.applyAsLong(field.get(object));
}
}
|
final V value = field.get(entity);
if (value == null) return null;
else return mapper.applyAsLong(value);
| 164
| 39
| 203
|
<methods>public ReferenceField<ENTITY,?,V> getField() ,public ToLongFunction<V> getMapper() ,public FieldIsNotNullPredicate<ENTITY,java.lang.Long> isNotNull() ,public FieldIsNullPredicate<ENTITY,java.lang.Long> isNull() <variables>final non-sealed ReferenceField<ENTITY,?,V> field,final non-sealed ToLongFunction<V> mapper
|
speedment_speedment
|
speedment/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/method/FindFromByte.java
|
FindFromByte
|
apply
|
class FindFromByte<ENTITY, FK_ENTITY> extends AbstractFindFrom<ENTITY, FK_ENTITY, Byte, ByteForeignKeyField<ENTITY, ?, FK_ENTITY>, ByteField<FK_ENTITY, ?>> {
public FindFromByte(
ByteForeignKeyField<ENTITY, ?, FK_ENTITY> source,
ByteField<FK_ENTITY, ?> target,
TableIdentifier<FK_ENTITY> identifier,
Supplier<Stream<FK_ENTITY>> streamSupplier) {
super(source, target, identifier, streamSupplier);
}
@Override
public FK_ENTITY apply(ENTITY entity) {<FILL_FUNCTION_BODY>}
}
|
final byte value = getSourceField().getter().applyAsByte(entity);
return stream()
.filter(getTargetField().equal(value))
.findAny()
.orElseThrow(() -> new SpeedmentFieldException(
"Error! Could not find any entities in table '" +
getTableIdentifier() +
"' with '" + getTargetField().identifier().getColumnId() +
"' = '" + value + "'."
));
| 189
| 114
| 303
|
<methods>public final ByteForeignKeyField<ENTITY,?,FK_ENTITY> getSourceField() ,public final TableIdentifier<FK_ENTITY> getTableIdentifier() ,public final ByteField<FK_ENTITY,?> getTargetField() <variables>private final non-sealed TableIdentifier<FK_ENTITY> identifier,private final non-sealed ByteForeignKeyField<ENTITY,?,FK_ENTITY> source,private final non-sealed Supplier<Stream<FK_ENTITY>> streamSupplier,private final non-sealed ByteField<FK_ENTITY,?> target
|
speedment_speedment
|
speedment/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/method/FindFromChar.java
|
FindFromChar
|
apply
|
class FindFromChar<ENTITY, FK_ENTITY> extends AbstractFindFrom<ENTITY, FK_ENTITY, Character, CharForeignKeyField<ENTITY, ?, FK_ENTITY>, CharField<FK_ENTITY, ?>> {
public FindFromChar(
CharForeignKeyField<ENTITY, ?, FK_ENTITY> source,
CharField<FK_ENTITY, ?> target,
TableIdentifier<FK_ENTITY> identifier,
Supplier<Stream<FK_ENTITY>> streamSupplier) {
super(source, target, identifier, streamSupplier);
}
@Override
public FK_ENTITY apply(ENTITY entity) {<FILL_FUNCTION_BODY>}
}
|
final char value = getSourceField().getter().applyAsChar(entity);
return stream()
.filter(getTargetField().equal(value))
.findAny()
.orElseThrow(() -> new SpeedmentFieldException(
"Error! Could not find any entities in table '" +
getTableIdentifier() +
"' with '" + getTargetField().identifier().getColumnId() +
"' = '" + value + "'."
));
| 189
| 114
| 303
|
<methods>public final CharForeignKeyField<ENTITY,?,FK_ENTITY> getSourceField() ,public final TableIdentifier<FK_ENTITY> getTableIdentifier() ,public final CharField<FK_ENTITY,?> getTargetField() <variables>private final non-sealed TableIdentifier<FK_ENTITY> identifier,private final non-sealed CharForeignKeyField<ENTITY,?,FK_ENTITY> source,private final non-sealed Supplier<Stream<FK_ENTITY>> streamSupplier,private final non-sealed CharField<FK_ENTITY,?> target
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.