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-field/src/main/java/com/speedment/runtime/field/internal/method/FindFromDouble.java
|
FindFromDouble
|
apply
|
class FindFromDouble<ENTITY, FK_ENTITY> extends AbstractFindFrom<ENTITY, FK_ENTITY, Double, DoubleForeignKeyField<ENTITY, ?, FK_ENTITY>, DoubleField<FK_ENTITY, ?>> {
public FindFromDouble(
DoubleForeignKeyField<ENTITY, ?, FK_ENTITY> source,
DoubleField<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 double value = getSourceField().getter().applyAsDouble(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 DoubleForeignKeyField<ENTITY,?,FK_ENTITY> getSourceField() ,public final TableIdentifier<FK_ENTITY> getTableIdentifier() ,public final DoubleField<FK_ENTITY,?> getTargetField() <variables>private final non-sealed TableIdentifier<FK_ENTITY> identifier,private final non-sealed DoubleForeignKeyField<ENTITY,?,FK_ENTITY> source,private final non-sealed Supplier<Stream<FK_ENTITY>> streamSupplier,private final non-sealed DoubleField<FK_ENTITY,?> target
|
speedment_speedment
|
speedment/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/method/FindFromFloat.java
|
FindFromFloat
|
apply
|
class FindFromFloat<ENTITY, FK_ENTITY> extends AbstractFindFrom<ENTITY, FK_ENTITY, Float, FloatForeignKeyField<ENTITY, ?, FK_ENTITY>, FloatField<FK_ENTITY, ?>> {
public FindFromFloat(
FloatForeignKeyField<ENTITY, ?, FK_ENTITY> source,
FloatField<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 float value = getSourceField().getter().applyAsFloat(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 + "'."
));
| 194
| 114
| 308
|
<methods>public final FloatForeignKeyField<ENTITY,?,FK_ENTITY> getSourceField() ,public final TableIdentifier<FK_ENTITY> getTableIdentifier() ,public final FloatField<FK_ENTITY,?> getTargetField() <variables>private final non-sealed TableIdentifier<FK_ENTITY> identifier,private final non-sealed FloatForeignKeyField<ENTITY,?,FK_ENTITY> source,private final non-sealed Supplier<Stream<FK_ENTITY>> streamSupplier,private final non-sealed FloatField<FK_ENTITY,?> target
|
speedment_speedment
|
speedment/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/method/FindFromInt.java
|
FindFromInt
|
apply
|
class FindFromInt<ENTITY, FK_ENTITY> extends AbstractFindFrom<ENTITY, FK_ENTITY, Integer, IntForeignKeyField<ENTITY, ?, FK_ENTITY>, IntField<FK_ENTITY, ?>> {
public FindFromInt(
IntForeignKeyField<ENTITY, ?, FK_ENTITY> source,
IntField<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 int value = getSourceField().getter().applyAsInt(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 IntForeignKeyField<ENTITY,?,FK_ENTITY> getSourceField() ,public final TableIdentifier<FK_ENTITY> getTableIdentifier() ,public final IntField<FK_ENTITY,?> getTargetField() <variables>private final non-sealed TableIdentifier<FK_ENTITY> identifier,private final non-sealed IntForeignKeyField<ENTITY,?,FK_ENTITY> source,private final non-sealed Supplier<Stream<FK_ENTITY>> streamSupplier,private final non-sealed IntField<FK_ENTITY,?> target
|
speedment_speedment
|
speedment/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/method/FindFromLong.java
|
FindFromLong
|
apply
|
class FindFromLong<ENTITY, FK_ENTITY> extends AbstractFindFrom<ENTITY, FK_ENTITY, Long, LongForeignKeyField<ENTITY, ?, FK_ENTITY>, LongField<FK_ENTITY, ?>> {
public FindFromLong(
LongForeignKeyField<ENTITY, ?, FK_ENTITY> source,
LongField<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 long value = getSourceField().getter().applyAsLong(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 LongForeignKeyField<ENTITY,?,FK_ENTITY> getSourceField() ,public final TableIdentifier<FK_ENTITY> getTableIdentifier() ,public final LongField<FK_ENTITY,?> getTargetField() <variables>private final non-sealed TableIdentifier<FK_ENTITY> identifier,private final non-sealed LongForeignKeyField<ENTITY,?,FK_ENTITY> source,private final non-sealed Supplier<Stream<FK_ENTITY>> streamSupplier,private final non-sealed LongField<FK_ENTITY,?> target
|
speedment_speedment
|
speedment/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/method/FindFromNullableReference.java
|
FindFromNullableReference
|
applyOrThrow
|
class FindFromNullableReference<
ENTITY, FK_ENTITY,
V extends Comparable<? super V>,
SOURCE extends Field<ENTITY>
& HasReferenceOperators<ENTITY>
& HasReferenceValue<ENTITY, ?, V>,
TARGET extends Field<FK_ENTITY>
& HasComparableOperators<FK_ENTITY, V>
> extends AbstractFindFromNullable<ENTITY, FK_ENTITY, V, SOURCE, TARGET>
implements FindFromNullable<ENTITY, FK_ENTITY> {
public FindFromNullableReference(
SOURCE source,
TARGET target,
TableIdentifier<FK_ENTITY> foreignTable,
Supplier<Stream<FK_ENTITY>> streamSupplier) {
super(source, target, foreignTable, streamSupplier);
}
@Override
public boolean isPresent(ENTITY entity) {
return getSourceField().isNotNull().test(entity);
}
@Override
public FK_ENTITY applyOrThrow(ENTITY entity) {<FILL_FUNCTION_BODY>}
@Override
public Stream<FK_ENTITY> apply(ENTITY entity) {
return stream().filter(
getTargetField().equal(getSourceField().get(entity))
);
}
}
|
return apply(entity).findAny()
.orElseThrow(() -> new IllegalArgumentException(format(
"Specified entity '%s' does not reference any %s.",
entity, getTableIdentifier()
)));
| 341
| 58
| 399
|
<methods>public final SOURCE getSourceField() ,public final TableIdentifier<FK_ENTITY> getTableIdentifier() ,public final TARGET getTargetField() <variables>private final non-sealed TableIdentifier<FK_ENTITY> identifier,private final non-sealed SOURCE source,private final non-sealed Supplier<Stream<FK_ENTITY>> streamSupplier,private final non-sealed TARGET target
|
speedment_speedment
|
speedment/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/method/FindFromReference.java
|
FindFromReference
|
apply
|
class FindFromReference<
ENTITY,
FK_ENTITY,
V extends Comparable<? super V>,
SOURCE extends Field<ENTITY> & HasComparableOperators<ENTITY, V> & HasFinder<ENTITY, FK_ENTITY>>
extends AbstractFindFrom<ENTITY, FK_ENTITY, V, SOURCE, HasComparableOperators<FK_ENTITY, V>> {
public FindFromReference(SOURCE source, HasComparableOperators<FK_ENTITY, V> 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>}
}
|
@SuppressWarnings("unchecked")
final V value = (V) getSourceField().getter().apply(entity);
if (value == null) {
return null;
} else {
return stream()
.filter(getTargetField().equal(value))
.findAny()
.orElseThrow(() -> new SpeedmentFieldException(
"Error! Could not find any entities in table '" +
getTableIdentifier() +
"' with '" + getTargetField().identifier().getColumnId() +
"' = '" + value + "'."
));
}
| 216
| 149
| 365
|
<methods>public final SOURCE getSourceField() ,public final TableIdentifier<FK_ENTITY> getTableIdentifier() ,public final HasComparableOperators<FK_ENTITY,V> getTargetField() <variables>private final non-sealed TableIdentifier<FK_ENTITY> identifier,private final non-sealed SOURCE source,private final non-sealed Supplier<Stream<FK_ENTITY>> streamSupplier,private final non-sealed HasComparableOperators<FK_ENTITY,V> target
|
speedment_speedment
|
speedment/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/method/FindFromShort.java
|
FindFromShort
|
apply
|
class FindFromShort<ENTITY, FK_ENTITY> extends AbstractFindFrom<ENTITY, FK_ENTITY, Short, ShortForeignKeyField<ENTITY, ?, FK_ENTITY>, ShortField<FK_ENTITY, ?>> {
public FindFromShort(
ShortForeignKeyField<ENTITY, ?, FK_ENTITY> source,
ShortField<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 short value = getSourceField().getter().applyAsShort(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 ShortForeignKeyField<ENTITY,?,FK_ENTITY> getSourceField() ,public final TableIdentifier<FK_ENTITY> getTableIdentifier() ,public final ShortField<FK_ENTITY,?> getTargetField() <variables>private final non-sealed TableIdentifier<FK_ENTITY> identifier,private final non-sealed ShortForeignKeyField<ENTITY,?,FK_ENTITY> source,private final non-sealed Supplier<Stream<FK_ENTITY>> streamSupplier,private final non-sealed ShortField<FK_ENTITY,?> target
|
speedment_speedment
|
speedment/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/predicate/AbstractCombinedPredicate.java
|
OrCombinedBasePredicateImpl
|
equals
|
class OrCombinedBasePredicateImpl<ENTITY>
extends AbstractCombinedPredicate<ENTITY> {
public OrCombinedBasePredicateImpl(
List<Predicate<? super ENTITY>> predicates) {
super(Type.OR, predicates);
}
@Override
public boolean applyAsBoolean(ENTITY entity) {
requireNonNull(entity);
return stream().anyMatch(p -> p.test(entity));
}
@Override
public CombinedPredicate<ENTITY> and(Predicate<? super ENTITY> other) {
requireNonNull(other);
return CombinedPredicate.and(this, other);
}
@Override
public CombinedPredicate<ENTITY> or(Predicate<? super ENTITY> other) {
requireNonNull(other);
return new OrCombinedBasePredicateImpl<>(
copyAndAdd(getPredicates(), other)
);
}
@Override
@SuppressWarnings("unchecked")
public AndCombinedBasePredicateImpl<ENTITY> negate() {
return new AndCombinedBasePredicateImpl<>(
getPredicates().stream()
.map(p -> (Predicate<ENTITY>) p)
.map(Predicate::negate)
.collect(toList())
);
}
}
@Override
public boolean equals(Object o) {<FILL_FUNCTION_BODY>
|
if (this == o) return true;
if (!(o instanceof CombinedPredicate)) return false;
final CombinedPredicate<?> that = (CombinedPredicate<?>) o;
final Iterator<Predicate<? super ENTITY>> it = predicates.iterator();
return getType() == that.getType()
&& that.stream().allMatch(it.next()::equals);
| 372
| 105
| 477
|
<methods>public SpeedmentPredicate<ENTITY> and(Predicate<? super ENTITY>) ,public SpeedmentPredicate<ENTITY> or(Predicate<? super ENTITY>) <variables>
|
speedment_speedment
|
speedment/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/predicate/AbstractFieldPredicate.java
|
AbstractFieldPredicate
|
toString
|
class AbstractFieldPredicate<ENTITY, FIELD extends Field<ENTITY>>
extends AbstractPredicate<ENTITY>
implements FieldPredicate<ENTITY> {
private final PredicateType predicateType;
private final FIELD field;
private final Predicate<ENTITY> tester;
protected AbstractFieldPredicate(
final PredicateType predicateType,
final FIELD field,
final Predicate<ENTITY> tester) {
this.predicateType = requireNonNull(predicateType);
this.field = requireNonNull(field);
this.tester = requireNonNull(tester);
}
protected final Predicate<ENTITY> getTester() {
return tester;
}
@Override
public boolean applyAsBoolean(ENTITY instance) {
return tester.test(instance);
}
@Override
public final PredicateType getPredicateType() {
return predicateType;
}
@Override
public final FIELD getField() {
return field;
}
@Override
public String toString() {<FILL_FUNCTION_BODY>}
}
|
final ColumnIdentifier<ENTITY> cId = field.identifier();
final StringBuilder sb = new StringBuilder();
sb.append(getClass().getSimpleName())
.append(" {")
.append("field: ")
.append(cId.getDbmsId()).append('.')
.append(cId.getSchemaId()).append('.')
.append(cId.getTableId()).append('.')
.append(cId.getColumnId())
.append(", type: '").append(predicateType).append("'");
Cast.cast(this, Tuple.class).ifPresent(tuple -> {
for (int i = 0; i < tuple.degree(); i++) {
sb.append(", operand ").append(i)
.append(": ").append(tuple.get(i));
}
});
return sb.append("}").toString();
| 291
| 228
| 519
|
<methods>public SpeedmentPredicate<ENTITY> and(Predicate<? super ENTITY>) ,public SpeedmentPredicate<ENTITY> or(Predicate<? super ENTITY>) <variables>
|
speedment_speedment
|
speedment/runtime-parent/runtime-field/src/main/java/com/speedment/runtime/field/internal/predicate/reference/ReferenceNotBetweenPredicate.java
|
ReferenceNotBetweenPredicate
|
entityPredicate
|
class ReferenceNotBetweenPredicate<ENTITY, D, V extends Comparable<? super V>>
extends AbstractFieldPredicate<ENTITY, HasReferenceValue<ENTITY, D, V>>
implements HasInclusion, Tuple2<V, V> {
private final V start;
private final V end;
private final Inclusion inclusion;
public ReferenceNotBetweenPredicate(
final HasReferenceValue<ENTITY, D, V> referenceField,
final V start,
final V end,
final Inclusion inclusion
) {
super(NOT_BETWEEN, referenceField, entityPredicate(referenceField, start, end, inclusion));
this.start = start;
this.end = end;
this.inclusion = requireNonNull(inclusion);
}
private static <ENTITY, D, V extends Comparable<? super V>> Predicate<ENTITY> entityPredicate(HasReferenceValue<ENTITY, D, V> referenceField, V start, V end, Inclusion inclusion) {<FILL_FUNCTION_BODY>}
private static <V extends Comparable<? super V>> boolean starInclusiveEndInclusive(V start, V end, V fieldValue) {
if (fieldValue == null) {
return start == null || end == null;
} else if (start == null || end == null) {
return false;
}
return !(start.compareTo(fieldValue) <= 0 && end.compareTo(fieldValue) >= 0);
}
private static <V extends Comparable<? super V>> boolean startInclusiveEndExclusive(V start, V end, V fieldValue) {
if (fieldValue == null) {
return start == null && end != null;
} else if (start == null || end == null) {
return false;
}
return !(start.compareTo(fieldValue) <= 0 && end.compareTo(fieldValue) > 0);
}
private static <V extends Comparable<? super V>> boolean startExclusiveEndInclusive(V start, V end, V fieldValue) {
if (fieldValue == null) {
return start != null && end == null;
} else if (start == null || end == null) {
return false;
} else return !(start.compareTo(fieldValue) < 0 && end.compareTo(fieldValue) >= 0);
}
private static <V extends Comparable<? super V>> boolean startExclusiveEndExclusive(V start, V end, V fieldValue) {
if (fieldValue == null) {
return false;
} else if (start == null || end == null) {
return false;
} else return !(start.compareTo(fieldValue) < 0 && end.compareTo(fieldValue) > 0);
}
@Override
public V get0() {
return start;
}
@Override
public V get1() {
return end;
}
@Override
public Inclusion getInclusion() {
return inclusion;
}
@Override
public ReferenceBetweenPredicate<ENTITY, D, V> negate() {
return new ReferenceBetweenPredicate<>(getField(), start, end, inclusion);
}
}
|
return entity -> {
final V fieldValue = referenceField.get(entity);
switch (inclusion) {
case START_EXCLUSIVE_END_EXCLUSIVE :
return startExclusiveEndExclusive(start, end, fieldValue);
case START_EXCLUSIVE_END_INCLUSIVE :
return startExclusiveEndInclusive(start, end, fieldValue);
case START_INCLUSIVE_END_EXCLUSIVE :
return startInclusiveEndExclusive(start, end, fieldValue);
case START_INCLUSIVE_END_INCLUSIVE :
return starInclusiveEndInclusive(start, end, fieldValue);
default : throw new IllegalStateException("Inclusion unknown: " + inclusion);
}
};
| 814
| 197
| 1,011
|
<methods>public boolean applyAsBoolean(ENTITY) ,public final HasReferenceValue<ENTITY,D,V> getField() ,public final com.speedment.runtime.field.predicate.PredicateType getPredicateType() ,public java.lang.String toString() <variables>private final non-sealed HasReferenceValue<ENTITY,D,V> field,private final non-sealed com.speedment.runtime.field.predicate.PredicateType predicateType,private final non-sealed Predicate<ENTITY> tester
|
speedment_speedment
|
speedment/runtime-parent/runtime-join/src/main/java/com/speedment/runtime/join/internal/component/join/JoinBuilder4Impl.java
|
AfterJoinImpl
|
build
|
class AfterJoinImpl<T4>
extends BaseAfterJoin<T4, JoinBuilder5<T0, T1, T2, T3, T4>>
implements AfterJoin<T0, T1, T2, T3, T4> {
private AfterJoinImpl(StageBean<T4> stageBean) {
super(JoinBuilder4Impl.this, stageBean, JoinBuilder5Impl::new);
}
}
@Override
@SuppressWarnings("unchecked")
public <T> Join<T> build(QuadFunction<T0, T1, T2, T3, T> constructor) {<FILL_FUNCTION_BODY>
|
requireNonNull(constructor);
final List<Stage<?>> stages = stages();
return streamSuppler().createJoin(
stages,
constructor,
(TableIdentifier<T0>) stages.get(0).identifier(),
(TableIdentifier<T1>) stages.get(1).identifier(),
(TableIdentifier<T2>) stages.get(2).identifier(),
(TableIdentifier<T3>) stages.get(3).identifier()
);
| 168
| 118
| 286
|
<methods>public JoinBuilder4<T0,T1,T2,T3> where(Predicate<? super T3>) <variables>private static final com.speedment.common.logger.Logger LOGGER_JOIN,private final non-sealed StageBean<T3> stageBean,private final non-sealed List<StageBean<?>> stageBeans,private final non-sealed com.speedment.runtime.join.JoinStreamSupplierComponent streamSupplier
|
speedment_speedment
|
speedment/runtime-parent/runtime-join/src/main/java/com/speedment/runtime/join/internal/component/join/JoinBuilder6Impl.java
|
AfterJoinImpl
|
build
|
class AfterJoinImpl<T6>
extends BaseAfterJoin<T6, JoinBuilder7<T0, T1, T2, T3, T4, T5, T6>>
implements AfterJoin<T0, T1, T2, T3, T4, T5, T6> {
private AfterJoinImpl(StageBean<T6> stageBean) {
super(JoinBuilder6Impl.this, stageBean, JoinBuilder7Impl::new);
}
}
@Override
@SuppressWarnings("unchecked")
public <T> Join<T> build(Function6<T0, T1, T2, T3, T4, T5, T> constructor) {<FILL_FUNCTION_BODY>
|
requireNonNull(constructor);
final List<Stage<?>> stages = stages();
return streamSuppler().createJoin(
stages,
constructor,
(TableIdentifier<T0>) stages.get(0).identifier(),
(TableIdentifier<T1>) stages.get(1).identifier(),
(TableIdentifier<T2>) stages.get(2).identifier(),
(TableIdentifier<T3>) stages.get(3).identifier(),
(TableIdentifier<T4>) stages.get(4).identifier(),
(TableIdentifier<T5>) stages.get(5).identifier()
);
| 185
| 154
| 339
|
<methods>public JoinBuilder6<T0,T1,T2,T3,T4,T5> where(Predicate<? super T5>) <variables>private static final com.speedment.common.logger.Logger LOGGER_JOIN,private final non-sealed StageBean<T5> stageBean,private final non-sealed List<StageBean<?>> stageBeans,private final non-sealed com.speedment.runtime.join.JoinStreamSupplierComponent streamSupplier
|
speedment_speedment
|
speedment/runtime-parent/runtime-join/src/main/java/com/speedment/runtime/join/internal/component/join/JoinBuilder7Impl.java
|
AfterJoinImpl
|
build
|
class AfterJoinImpl<T7>
extends BaseAfterJoin<T7, JoinBuilder8<T0, T1, T2, T3, T4, T5, T6, T7>>
implements AfterJoin<T0, T1, T2, T3, T4, T5, T6, T7> {
private AfterJoinImpl(StageBean<T7> stageBean) {
super(JoinBuilder7Impl.this, stageBean, JoinBuilder8Impl::new);
}
}
@Override
@SuppressWarnings("unchecked")
public <T> Join<T> build(Function7<T0, T1, T2, T3, T4, T5, T6, T> constructor) {<FILL_FUNCTION_BODY>
|
requireNonNull(constructor);
final List<Stage<?>> stages = stages();
return streamSuppler().createJoin(
stages,
constructor,
(TableIdentifier<T0>) stages.get(0).identifier(),
(TableIdentifier<T1>) stages.get(1).identifier(),
(TableIdentifier<T2>) stages.get(2).identifier(),
(TableIdentifier<T3>) stages.get(3).identifier(),
(TableIdentifier<T4>) stages.get(4).identifier(),
(TableIdentifier<T5>) stages.get(5).identifier(),
(TableIdentifier<T6>) stages.get(6).identifier()
);
| 194
| 172
| 366
|
<methods>public JoinBuilder7<T0,T1,T2,T3,T4,T5,T6> where(Predicate<? super T6>) <variables>private static final com.speedment.common.logger.Logger LOGGER_JOIN,private final non-sealed StageBean<T6> stageBean,private final non-sealed List<StageBean<?>> stageBeans,private final non-sealed com.speedment.runtime.join.JoinStreamSupplierComponent streamSupplier
|
speedment_speedment
|
speedment/runtime-parent/runtime-join/src/main/java/com/speedment/runtime/join/internal/component/join/JoinBuilder9Impl.java
|
AfterJoinImpl
|
build
|
class AfterJoinImpl<T9>
extends BaseAfterJoin<T9, JoinBuilder10<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>>
implements AfterJoin<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> {
private AfterJoinImpl(StageBean<T9> stageBean) {
super(JoinBuilder9Impl.this, stageBean, JoinBuilder10Impl::new);
}
}
@Override
@SuppressWarnings("unchecked")
public <T> Join<T> build(Function9<T0, T1, T2, T3, T4, T5, T6, T7, T8, T> constructor) {<FILL_FUNCTION_BODY>
|
requireNonNull(constructor);
final List<Stage<?>> stages = stages();
return streamSuppler().createJoin(
stages,
constructor,
(TableIdentifier<T0>) stages.get(0).identifier(),
(TableIdentifier<T1>) stages.get(1).identifier(),
(TableIdentifier<T2>) stages.get(2).identifier(),
(TableIdentifier<T3>) stages.get(3).identifier(),
(TableIdentifier<T4>) stages.get(4).identifier(),
(TableIdentifier<T5>) stages.get(5).identifier(),
(TableIdentifier<T6>) stages.get(6).identifier(),
(TableIdentifier<T7>) stages.get(7).identifier(),
(TableIdentifier<T8>) stages.get(8).identifier()
);
| 214
| 208
| 422
|
<methods>public JoinBuilder9<T0,T1,T2,T3,T4,T5,T6,T7,T8> where(Predicate<? super T8>) <variables>private static final com.speedment.common.logger.Logger LOGGER_JOIN,private final non-sealed StageBean<T8> stageBean,private final non-sealed List<StageBean<?>> stageBeans,private final non-sealed com.speedment.runtime.join.JoinStreamSupplierComponent streamSupplier
|
speedment_speedment
|
speedment/runtime-parent/runtime-join/src/main/java/com/speedment/runtime/join/internal/component/join/StageBean.java
|
StageBean
|
asStage
|
class StageBean<T> {
private final TableIdentifier<T> identifier;
private final List<Predicate<? super T>> predicates;
private JoinType joinType;
private HasComparableOperators<T, ?> field;
private JoinOperator joinOperator;
private HasComparableOperators<?, ?> foreignField;
private int referencedStage;
// private HasComparableOperators<?, ?> foreignSecondField;
// private Inclusion foreignInclusion;
StageBean(TableIdentifier<T> identifier) {
this.identifier = requireNonNull(identifier);
this.predicates = new ArrayList<>();
}
StageBean(TableIdentifier<T> identifier, JoinType joinType) {
this.identifier = requireNonNull(identifier);
this.predicates = new ArrayList<>();
this.joinType = requireNonNull(joinType);
}
StageBean(JoinType joinType, HasComparableOperators<T, ?> field) {
requireNonNull(field);
this.identifier = requireNonNull(field.identifier().asTableIdentifier());
this.predicates = new ArrayList<>();
this.joinType = requireNonNull(joinType);
this.field = field;
}
JoinType getJoinType() {
return joinType;
}
void setJoinType(JoinType joinType) {
this.joinType = requireNonNull(joinType);
}
HasComparableOperators<? extends T, ?> getField() {
return field;
}
void setField(HasComparableOperators<T, ?> field) {
this.field = requireNonNull(field);
}
JoinOperator getJoinOperator() {
return joinOperator;
}
void setJoinOperator(JoinOperator joinOperator) {
this.joinOperator = requireNonNull(joinOperator);
}
HasComparableOperators<?, ?> getForeignField() {
return foreignField;
}
void setForeignField(HasComparableOperators<?, ?> foreignFirstField) {
this.foreignField = requireNonNull(foreignFirstField);
}
int getReferencedStage() {
return referencedStage;
}
void setReferencedStage(int referencedStage) {
this.referencedStage = referencedStage;
}
// public HasComparableOperators<?, ?> getForeignSecondField() {
// return foreignSecondField;
// }
//
// public void setForeignSecondField(HasComparableOperators<?, ?> foreignSecondField) {
// this.foreignSecondField = requireNonNull(foreignSecondField);
// }
TableIdentifier<T> getIdentifier() {
return identifier;
}
/**
* This list is intentionally exposed for mutable operation.
*
* @return a mutable list
*/
List<Predicate<? super T>> getPredicates() {
return predicates;
}
// public Inclusion getForeignInclusion() {
// return foreignInclusion;
// }
//
// public void setForeignInclusion(Inclusion foreignInclusion) {
// this.foreignInclusion = requireNonNull(foreignInclusion);
// }
Stage<T> asStage() {<FILL_FUNCTION_BODY>}
}
|
return Stage.of(
identifier,
predicates,
joinType,
field,
joinOperator,
foreignField,
referencedStage
// foreignSecondField,
// foreignInclusion
);
| 863
| 60
| 923
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-join/src/main/java/com/speedment/runtime/join/internal/component/stream/sql/AbstractSqlHasCreateJoin.java
|
AbstractSqlHasCreateJoin
|
newJoin
|
class AbstractSqlHasCreateJoin {
private final DbmsHandlerComponent dbmsHandlerComponent;
private final Project project;
private final SqlAdapterMapper sqlAdapterMapper;
private final boolean allowStreamIteratorAndSpliterator;
AbstractSqlHasCreateJoin(
final DbmsHandlerComponent dbmsHandlerComponent,
final Project project,
final SqlAdapterMapper sqlAdapterMapper,
final boolean allowStreamIteratorAndSpliterator
) {
this.dbmsHandlerComponent = requireNonNull(dbmsHandlerComponent);
this.project = requireNonNull(project);
this.sqlAdapterMapper = requireNonNull(sqlAdapterMapper);
this.allowStreamIteratorAndSpliterator = allowStreamIteratorAndSpliterator;
}
<T> SqlFunction<ResultSet, T> rsMapper(
final List<Stage<?>> stages,
final int stageIndex,
final TableIdentifier<T> identifier
) {
return resultSetMapper(project, identifier, stages, stageIndex, sqlAdapterMapper);
}
<T> Join<T> newJoin(final List<Stage<?>> stages, final SqlFunction<ResultSet, T> rsMapper) {<FILL_FUNCTION_BODY>}
}
|
requireNonNull(stages);
requireNonNull(rsMapper);
return new JoinImpl<>(
() -> JoinSqlUtil.stream(dbmsHandlerComponent, project, stages, rsMapper, allowStreamIteratorAndSpliterator)
);
| 299
| 64
| 363
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-join/src/main/java/com/speedment/runtime/join/internal/component/stream/sql/SqlHasCreateJoin10.java
|
SqlHasCreateJoin10
|
createJoin
|
class SqlHasCreateJoin10
extends AbstractSqlHasCreateJoin
implements HasCreateJoin10 {
public SqlHasCreateJoin10(
final DbmsHandlerComponent dbmsHandlerComponent,
final Project project,
final SqlAdapterMapper sqlAdapterMapper,
final boolean allowStreamIteratorAndSpliterator
) {
super(dbmsHandlerComponent, project, sqlAdapterMapper, allowStreamIteratorAndSpliterator);
}
@Override
public <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T> Join<T> createJoin(
final List<Stage<?>> stages,
final Function10<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T> constructor,
final TableIdentifier<T0> t0,
final TableIdentifier<T1> t1,
final TableIdentifier<T2> t2,
final TableIdentifier<T3> t3,
final TableIdentifier<T4> t4,
final TableIdentifier<T5> t5,
final TableIdentifier<T6> t6,
final TableIdentifier<T7> t7,
final TableIdentifier<T8> t8,
final TableIdentifier<T9> t9
) {<FILL_FUNCTION_BODY>}
}
|
final SqlFunction<ResultSet, T0> rsMapper0 = rsMapper(stages, 0, t0);
final SqlFunction<ResultSet, T1> rsMapper1 = rsMapper(stages, 1, t1);
final SqlFunction<ResultSet, T2> rsMapper2 = rsMapper(stages, 2, t2);
final SqlFunction<ResultSet, T3> rsMapper3 = rsMapper(stages, 3, t3);
final SqlFunction<ResultSet, T4> rsMapper4 = rsMapper(stages, 4, t4);
final SqlFunction<ResultSet, T5> rsMapper5 = rsMapper(stages, 5, t5);
final SqlFunction<ResultSet, T6> rsMapper6 = rsMapper(stages, 6, t6);
final SqlFunction<ResultSet, T7> rsMapper7 = rsMapper(stages, 7, t7);
final SqlFunction<ResultSet, T8> rsMapper8 = rsMapper(stages, 8, t8);
final SqlFunction<ResultSet, T9> rsMapper9 = rsMapper(stages, 9, t9);
final SqlFunction<ResultSet, T> rsMapper = rs -> constructor.apply(
rsMapper0.apply(rs),
rsMapper1.apply(rs),
rsMapper2.apply(rs),
rsMapper3.apply(rs),
rsMapper4.apply(rs),
rsMapper5.apply(rs),
rsMapper6.apply(rs),
rsMapper7.apply(rs),
rsMapper8.apply(rs),
rsMapper9.apply(rs)
);
return newJoin(stages, rsMapper);
| 345
| 452
| 797
|
<methods><variables>private final non-sealed boolean allowStreamIteratorAndSpliterator,private final non-sealed com.speedment.runtime.core.component.DbmsHandlerComponent dbmsHandlerComponent,private final non-sealed com.speedment.runtime.config.Project project,private final non-sealed com.speedment.runtime.join.internal.component.stream.SqlAdapterMapper sqlAdapterMapper
|
speedment_speedment
|
speedment/runtime-parent/runtime-join/src/main/java/com/speedment/runtime/join/internal/component/stream/sql/SqlHasCreateJoin2.java
|
SqlHasCreateJoin2
|
createJoin
|
class SqlHasCreateJoin2
extends AbstractSqlHasCreateJoin
implements HasCreateJoin2 {
public SqlHasCreateJoin2(
final DbmsHandlerComponent dbmsHandlerComponent,
final Project project,
final SqlAdapterMapper sqlAdapterMapper,
final boolean allowStreamIteratorAndSpliterator
) {
super(dbmsHandlerComponent, project, sqlAdapterMapper, allowStreamIteratorAndSpliterator);
}
@Override
public <T0, T1, T> Join<T> createJoin(
final List<Stage<?>> stages,
final BiFunction<T0, T1, T> constructor,
final TableIdentifier<T0> t0,
final TableIdentifier<T1> t1
) {<FILL_FUNCTION_BODY>}
}
|
final SqlFunction<ResultSet, T0> rsMapper0 = rsMapper(stages, 0, t0);
final SqlFunction<ResultSet, T1> rsMapper1 = rsMapper(stages, 1, t1);
final SqlFunction<ResultSet, T> rsMapper = rs -> constructor.apply(
rsMapper0.apply(rs),
rsMapper1.apply(rs)
);
return newJoin(stages, rsMapper);
| 197
| 124
| 321
|
<methods><variables>private final non-sealed boolean allowStreamIteratorAndSpliterator,private final non-sealed com.speedment.runtime.core.component.DbmsHandlerComponent dbmsHandlerComponent,private final non-sealed com.speedment.runtime.config.Project project,private final non-sealed com.speedment.runtime.join.internal.component.stream.SqlAdapterMapper sqlAdapterMapper
|
speedment_speedment
|
speedment/runtime-parent/runtime-join/src/main/java/com/speedment/runtime/join/internal/component/stream/sql/SqlHasCreateJoin5.java
|
SqlHasCreateJoin5
|
createJoin
|
class SqlHasCreateJoin5
extends AbstractSqlHasCreateJoin
implements HasCreateJoin5 {
public SqlHasCreateJoin5(
final DbmsHandlerComponent dbmsHandlerComponent,
final Project project,
final SqlAdapterMapper sqlAdapterMapper,
final boolean allowStreamIteratorAndSpliterator
) {
super(dbmsHandlerComponent, project, sqlAdapterMapper, allowStreamIteratorAndSpliterator);
}
@Override
public <T0, T1, T2, T3, T4, T> Join<T> createJoin(
final List<Stage<?>> stages,
final Function5<T0, T1, T2, T3, T4, T> constructor,
final TableIdentifier<T0> t0,
final TableIdentifier<T1> t1,
final TableIdentifier<T2> t2,
final TableIdentifier<T3> t3,
final TableIdentifier<T4> t4
) {<FILL_FUNCTION_BODY>}
}
|
final SqlFunction<ResultSet, T0> rsMapper0 = rsMapper(stages, 0, t0);
final SqlFunction<ResultSet, T1> rsMapper1 = rsMapper(stages, 1, t1);
final SqlFunction<ResultSet, T2> rsMapper2 = rsMapper(stages, 2, t2);
final SqlFunction<ResultSet, T3> rsMapper3 = rsMapper(stages, 3, t3);
final SqlFunction<ResultSet, T4> rsMapper4 = rsMapper(stages, 4, t4);
final SqlFunction<ResultSet, T> rsMapper = rs -> constructor.apply(
rsMapper0.apply(rs),
rsMapper1.apply(rs),
rsMapper2.apply(rs),
rsMapper3.apply(rs),
rsMapper4.apply(rs)
);
return newJoin(stages, rsMapper);
| 251
| 247
| 498
|
<methods><variables>private final non-sealed boolean allowStreamIteratorAndSpliterator,private final non-sealed com.speedment.runtime.core.component.DbmsHandlerComponent dbmsHandlerComponent,private final non-sealed com.speedment.runtime.config.Project project,private final non-sealed com.speedment.runtime.join.internal.component.stream.SqlAdapterMapper sqlAdapterMapper
|
speedment_speedment
|
speedment/runtime-parent/runtime-join/src/main/java/com/speedment/runtime/join/internal/component/stream/sql/SqlHasCreateJoin6.java
|
SqlHasCreateJoin6
|
createJoin
|
class SqlHasCreateJoin6
extends AbstractSqlHasCreateJoin
implements HasCreateJoin6 {
public SqlHasCreateJoin6(
final DbmsHandlerComponent dbmsHandlerComponent,
final Project project,
final SqlAdapterMapper sqlAdapterMapper,
final boolean allowStreamIteratorAndSpliterator
) {
super(dbmsHandlerComponent, project, sqlAdapterMapper, allowStreamIteratorAndSpliterator);
}
@Override
public <T0, T1, T2, T3, T4, T5, T> Join<T> createJoin(
final List<Stage<?>> stages,
final Function6<T0, T1, T2, T3, T4, T5, T> constructor,
final TableIdentifier<T0> t0,
final TableIdentifier<T1> t1,
final TableIdentifier<T2> t2,
final TableIdentifier<T3> t3,
final TableIdentifier<T4> t4,
final TableIdentifier<T5> t5
) {<FILL_FUNCTION_BODY>}
}
|
final SqlFunction<ResultSet, T0> rsMapper0 = rsMapper(stages, 0, t0);
final SqlFunction<ResultSet, T1> rsMapper1 = rsMapper(stages, 1, t1);
final SqlFunction<ResultSet, T2> rsMapper2 = rsMapper(stages, 2, t2);
final SqlFunction<ResultSet, T3> rsMapper3 = rsMapper(stages, 3, t3);
final SqlFunction<ResultSet, T4> rsMapper4 = rsMapper(stages, 4, t4);
final SqlFunction<ResultSet, T5> rsMapper5 = rsMapper(stages, 5, t5);
final SqlFunction<ResultSet, T> rsMapper = rs -> constructor.apply(
rsMapper0.apply(rs),
rsMapper1.apply(rs),
rsMapper2.apply(rs),
rsMapper3.apply(rs),
rsMapper4.apply(rs),
rsMapper5.apply(rs)
);
return newJoin(stages, rsMapper);
| 269
| 288
| 557
|
<methods><variables>private final non-sealed boolean allowStreamIteratorAndSpliterator,private final non-sealed com.speedment.runtime.core.component.DbmsHandlerComponent dbmsHandlerComponent,private final non-sealed com.speedment.runtime.config.Project project,private final non-sealed com.speedment.runtime.join.internal.component.stream.SqlAdapterMapper sqlAdapterMapper
|
speedment_speedment
|
speedment/runtime-parent/runtime-join/src/main/java/com/speedment/runtime/join/internal/component/stream/sql/SqlHasCreateJoin7.java
|
SqlHasCreateJoin7
|
createJoin
|
class SqlHasCreateJoin7
extends AbstractSqlHasCreateJoin
implements HasCreateJoin7 {
public SqlHasCreateJoin7(
final DbmsHandlerComponent dbmsHandlerComponent,
final Project project,
final SqlAdapterMapper sqlAdapterMapper,
final boolean allowStreamIteratorAndSpliterator
) {
super(dbmsHandlerComponent, project, sqlAdapterMapper, allowStreamIteratorAndSpliterator);
}
@Override
public <T0, T1, T2, T3, T4, T5, T6, T> Join<T> createJoin(
final List<Stage<?>> stages,
final Function7<T0, T1, T2, T3, T4, T5, T6, T> constructor,
final TableIdentifier<T0> t0,
final TableIdentifier<T1> t1,
final TableIdentifier<T2> t2,
final TableIdentifier<T3> t3,
final TableIdentifier<T4> t4,
final TableIdentifier<T5> t5,
final TableIdentifier<T6> t6
) {<FILL_FUNCTION_BODY>}
}
|
final SqlFunction<ResultSet, T0> rsMapper0 = rsMapper(stages, 0, t0);
final SqlFunction<ResultSet, T1> rsMapper1 = rsMapper(stages, 1, t1);
final SqlFunction<ResultSet, T2> rsMapper2 = rsMapper(stages, 2, t2);
final SqlFunction<ResultSet, T3> rsMapper3 = rsMapper(stages, 3, t3);
final SqlFunction<ResultSet, T4> rsMapper4 = rsMapper(stages, 4, t4);
final SqlFunction<ResultSet, T5> rsMapper5 = rsMapper(stages, 5, t5);
final SqlFunction<ResultSet, T6> rsMapper6 = rsMapper(stages, 6, t6);
final SqlFunction<ResultSet, T> rsMapper = rs -> constructor.apply(
rsMapper0.apply(rs),
rsMapper1.apply(rs),
rsMapper2.apply(rs),
rsMapper3.apply(rs),
rsMapper4.apply(rs),
rsMapper5.apply(rs),
rsMapper6.apply(rs)
);
return newJoin(stages, rsMapper);
| 288
| 329
| 617
|
<methods><variables>private final non-sealed boolean allowStreamIteratorAndSpliterator,private final non-sealed com.speedment.runtime.core.component.DbmsHandlerComponent dbmsHandlerComponent,private final non-sealed com.speedment.runtime.config.Project project,private final non-sealed com.speedment.runtime.join.internal.component.stream.SqlAdapterMapper sqlAdapterMapper
|
speedment_speedment
|
speedment/runtime-parent/runtime-join/src/main/java/com/speedment/runtime/join/internal/component/stream/sql/SqlHasCreateJoin8.java
|
SqlHasCreateJoin8
|
createJoin
|
class SqlHasCreateJoin8
extends AbstractSqlHasCreateJoin
implements HasCreateJoin8 {
public SqlHasCreateJoin8(
final DbmsHandlerComponent dbmsHandlerComponent,
final Project project,
final SqlAdapterMapper sqlAdapterMapper,
final boolean allowStreamIteratorAndSpliterator
) {
super(dbmsHandlerComponent, project, sqlAdapterMapper, allowStreamIteratorAndSpliterator);
}
@Override
public <T0, T1, T2, T3, T4, T5, T6, T7, T> Join<T> createJoin(
final List<Stage<?>> stages,
final Function8<T0, T1, T2, T3, T4, T5, T6, T7, T> constructor,
final TableIdentifier<T0> t0,
final TableIdentifier<T1> t1,
final TableIdentifier<T2> t2,
final TableIdentifier<T3> t3,
final TableIdentifier<T4> t4,
final TableIdentifier<T5> t5,
final TableIdentifier<T6> t6,
final TableIdentifier<T7> t7
) {<FILL_FUNCTION_BODY>}
}
|
final SqlFunction<ResultSet, T0> rsMapper0 = rsMapper(stages, 0, t0);
final SqlFunction<ResultSet, T1> rsMapper1 = rsMapper(stages, 1, t1);
final SqlFunction<ResultSet, T2> rsMapper2 = rsMapper(stages, 2, t2);
final SqlFunction<ResultSet, T3> rsMapper3 = rsMapper(stages, 3, t3);
final SqlFunction<ResultSet, T4> rsMapper4 = rsMapper(stages, 4, t4);
final SqlFunction<ResultSet, T5> rsMapper5 = rsMapper(stages, 5, t5);
final SqlFunction<ResultSet, T6> rsMapper6 = rsMapper(stages, 6, t6);
final SqlFunction<ResultSet, T7> rsMapper7= rsMapper(stages, 7, t7);
final SqlFunction<ResultSet, T> rsMapper = rs -> constructor.apply(
rsMapper0.apply(rs),
rsMapper1.apply(rs),
rsMapper2.apply(rs),
rsMapper3.apply(rs),
rsMapper4.apply(rs),
rsMapper5.apply(rs),
rsMapper6.apply(rs),
rsMapper7.apply(rs)
);
return newJoin(stages, rsMapper);
| 305
| 370
| 675
|
<methods><variables>private final non-sealed boolean allowStreamIteratorAndSpliterator,private final non-sealed com.speedment.runtime.core.component.DbmsHandlerComponent dbmsHandlerComponent,private final non-sealed com.speedment.runtime.config.Project project,private final non-sealed com.speedment.runtime.join.internal.component.stream.SqlAdapterMapper sqlAdapterMapper
|
speedment_speedment
|
speedment/runtime-parent/runtime-join/src/main/java/com/speedment/runtime/join/internal/component/stream/sql/SqlHasCreateJoin9.java
|
SqlHasCreateJoin9
|
createJoin
|
class SqlHasCreateJoin9
extends AbstractSqlHasCreateJoin
implements HasCreateJoin9 {
public SqlHasCreateJoin9(
final DbmsHandlerComponent dbmsHandlerComponent,
final Project project,
final SqlAdapterMapper sqlAdapterMapper,
final boolean allowStreamIteratorAndSpliterator
) {
super(dbmsHandlerComponent, project, sqlAdapterMapper, allowStreamIteratorAndSpliterator);
}
@Override
public <T0, T1, T2, T3, T4, T5, T6, T7, T8, T> Join<T> createJoin(
final List<Stage<?>> stages,
final Function9<T0, T1, T2, T3, T4, T5, T6, T7, T8, T> constructor,
final TableIdentifier<T0> t0,
final TableIdentifier<T1> t1,
final TableIdentifier<T2> t2,
final TableIdentifier<T3> t3,
final TableIdentifier<T4> t4,
final TableIdentifier<T5> t5,
final TableIdentifier<T6> t6,
final TableIdentifier<T7> t7,
final TableIdentifier<T8> t8
) {<FILL_FUNCTION_BODY>}
}
|
final SqlFunction<ResultSet, T0> rsMapper0 = rsMapper(stages, 0, t0);
final SqlFunction<ResultSet, T1> rsMapper1 = rsMapper(stages, 1, t1);
final SqlFunction<ResultSet, T2> rsMapper2 = rsMapper(stages, 2, t2);
final SqlFunction<ResultSet, T3> rsMapper3 = rsMapper(stages, 3, t3);
final SqlFunction<ResultSet, T4> rsMapper4 = rsMapper(stages, 4, t4);
final SqlFunction<ResultSet, T5> rsMapper5 = rsMapper(stages, 5, t5);
final SqlFunction<ResultSet, T6> rsMapper6 = rsMapper(stages, 6, t6);
final SqlFunction<ResultSet, T7> rsMapper7 = rsMapper(stages, 7, t7);
final SqlFunction<ResultSet, T8> rsMapper8 = rsMapper(stages, 8, t8);
final SqlFunction<ResultSet, T> rsMapper = rs -> constructor.apply(
rsMapper0.apply(rs),
rsMapper1.apply(rs),
rsMapper2.apply(rs),
rsMapper3.apply(rs),
rsMapper4.apply(rs),
rsMapper5.apply(rs),
rsMapper6.apply(rs),
rsMapper7.apply(rs),
rsMapper8.apply(rs)
);
return newJoin(stages, rsMapper);
| 323
| 411
| 734
|
<methods><variables>private final non-sealed boolean allowStreamIteratorAndSpliterator,private final non-sealed com.speedment.runtime.core.component.DbmsHandlerComponent dbmsHandlerComponent,private final non-sealed com.speedment.runtime.config.Project project,private final non-sealed com.speedment.runtime.join.internal.component.stream.SqlAdapterMapper sqlAdapterMapper
|
speedment_speedment
|
speedment/runtime-parent/runtime-join/src/main/java/com/speedment/runtime/join/internal/component/stream/sql/SqlInfo.java
|
SqlInfo
|
sqlStages
|
class SqlInfo {
private final Project project;
private final Dbms dbms;
private final DbmsType dbmsType;
private final DatabaseNamingConvention naming;
private final FieldPredicateView fieldPredicateView;
private final List<Stage<?>> stages;
SqlInfo(
final DbmsHandlerComponent dbmsHandlerComponent,
final Project project,
final List<Stage<?>> stages
) {
requireNonNull(project);
requireNonNull(dbmsHandlerComponent);
this.stages = requireNonNull(stages);
this.project = project;
this.dbms = requireSameDbms(project, stages);
this.dbmsType = DatabaseUtil.dbmsTypeOf(dbmsHandlerComponent, dbms);
this.naming = dbmsType.getDatabaseNamingConvention();
this.fieldPredicateView = dbmsType.getFieldPredicateView();
}
Project project() {
return project;
}
Dbms dbms() {
return dbms;
}
DbmsType dbmsType() {
return dbmsType;
}
DatabaseNamingConvention namingConvention() {
return naming;
}
FieldPredicateView fieldPredicateView() {
return fieldPredicateView;
}
List<SqlStage> sqlStages() {<FILL_FUNCTION_BODY>}
}
|
final List<SqlStage> sqlStages = new ArrayList<>();
for (int i = 0; i < stages.size(); i++) {
sqlStages.add(new SqlStage(this, stages.get(i), i));
}
return sqlStages;
| 366
| 72
| 438
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-join/src/main/java/com/speedment/runtime/join/internal/stage/StageImpl.java
|
StageImpl
|
toString
|
class StageImpl<T> implements Stage<T> {
private final TableIdentifier<T> identifier;
private final List<Predicate<? super T>> predicates;
private final JoinType joinType;
private final HasComparableOperators<T, ?> field;
private final JoinOperator joinOperator;
private final HasComparableOperators<?, ?> foreignFirstField;
private final int referencedStage;
// private final HasComparableOperators<?, ?> foreignSecondField;
// private final Inclusion foreignInclusion;
public StageImpl(
final TableIdentifier<T> identifier,
final List<Predicate<? super T>> predicates,
final JoinType joinType,
final HasComparableOperators<T, ?> field,
final JoinOperator joinOperator,
final HasComparableOperators<?, ?> foreignField,
final int referencedStage
// final HasComparableOperators<?, ?> foreignSecondField,
// final Inclusion foreignInclusion
) {
this.identifier = requireNonNull(identifier);
this.predicates = predicates; // Nullable
this.joinType = joinType; // Nullable
this.field = field; // Nullable
this.joinOperator = joinOperator; // Nullable
this.foreignFirstField = foreignField; // Nullable
this.referencedStage = referencedStage;
// this.foreignSecondField = foreignSecondField; // Nullable
// this.foreignInclusion = foreignInclusion; // Nullable
}
@Override
public TableIdentifier<T> identifier() {
return identifier;
}
@Override
public List<Predicate<? super T>> predicates() {
return Collections.unmodifiableList(predicates);
}
@Override
public Optional<JoinType> joinType() {
return Optional.ofNullable(joinType);
}
@Override
public Optional<HasComparableOperators<T, ?>> field() {
return Optional.ofNullable(field);
}
@Override
public Optional<JoinOperator> joinOperator() {
return Optional.ofNullable(joinOperator);
}
@Override
public Optional<HasComparableOperators<?, ?>> foreignField() {
return Optional.ofNullable(foreignFirstField);
}
@Override
public int referencedStage() {
return referencedStage;
}
// @Override
// public Optional<HasComparableOperators<?, ?>> foreignSecondField() {
// return Optional.ofNullable(foreignSecondField);
// }
//
// @Override
// public Optional<Inclusion> foreignInclusion() {
// return Optional.ofNullable(foreignInclusion);
// }
@Override
public String toString() {<FILL_FUNCTION_BODY>}
}
|
return "StageImpl{" +
"identifier=" + identifier +
", predicates=" + predicates +
", joinType=" + joinType +
", field=" + field +
", joinOperator=" + joinOperator +
", foreignFirstField=" + foreignFirstField +
", referencedStage=" + referencedStage +
'}';
| 722
| 96
| 818
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-join/src/main/java/com/speedment/runtime/join/provider/DelegateSqlJoinStreamSupplierComponent.java
|
DelegateSqlJoinStreamSupplierComponent
|
createJoin
|
class DelegateSqlJoinStreamSupplierComponent implements JoinStreamSupplierComponent {
private final SqlJoinStreamSupplierComponent inner;
public DelegateSqlJoinStreamSupplierComponent(
@Config(name = "allowStreamIteratorAndSpliterator", value = "false") final boolean allowStreamIteratorAndSpliterator
) {
this.inner = new SqlJoinStreamSupplierComponent(allowStreamIteratorAndSpliterator);
}
@Execute
public void init(Injector injector, ProjectComponent projectComponent, DbmsHandlerComponent dbmsHandlerComponent) {
inner.init(injector, projectComponent, dbmsHandlerComponent);
}
@Override
public <T0, T1, T> Join<T> createJoin(List<Stage<?>> stages, BiFunction<T0, T1, T> constructor, TableIdentifier<T0> t0, TableIdentifier<T1> t1) {
return inner.createJoin(stages, constructor, t0, t1);
}
@Override
public <T0, T1, T2, T> Join<T> createJoin(List<Stage<?>> stages, TriFunction<T0, T1, T2, T> constructor, TableIdentifier<T0> t0, TableIdentifier<T1> t1, TableIdentifier<T2> t2) {
return inner.createJoin(stages, constructor, t0, t1, t2);
}
@Override
public <T0, T1, T2, T3, T> Join<T> createJoin(List<Stage<?>> stages, QuadFunction<T0, T1, T2, T3, T> constructor, TableIdentifier<T0> t0, TableIdentifier<T1> t1, TableIdentifier<T2> t2, TableIdentifier<T3> t3) {
return inner.createJoin(stages, constructor, t0, t1, t2, t3);
}
@Override
public <T0, T1, T2, T3, T4, T> Join<T> createJoin(List<Stage<?>> stages, Function5<T0, T1, T2, T3, T4, T> constructor, TableIdentifier<T0> t0, TableIdentifier<T1> t1, TableIdentifier<T2> t2, TableIdentifier<T3> t3, TableIdentifier<T4> t4) {
return inner.createJoin(stages, constructor, t0, t1, t2, t3, t4);
}
@Override
public <T0, T1, T2, T3, T4, T5, T> Join<T> createJoin(List<Stage<?>> stages, Function6<T0, T1, T2, T3, T4, T5, T> constructor, TableIdentifier<T0> t0, TableIdentifier<T1> t1, TableIdentifier<T2> t2, TableIdentifier<T3> t3, TableIdentifier<T4> t4, TableIdentifier<T5> t5) {
return inner.createJoin(stages, constructor, t0, t1, t2, t3, t4, t5);
}
@Override
public <T0, T1, T2, T3, T4, T5, T6, T> Join<T> createJoin(List<Stage<?>> stages, Function7<T0, T1, T2, T3, T4, T5, T6, T> constructor, TableIdentifier<T0> t0, TableIdentifier<T1> t1, TableIdentifier<T2> t2, TableIdentifier<T3> t3, TableIdentifier<T4> t4, TableIdentifier<T5> t5, TableIdentifier<T6> t6) {
return inner.createJoin(stages, constructor, t0, t1, t2, t3, t4, t5, t6);
}
@Override
public <T0, T1, T2, T3, T4, T5, T6, T7, T> Join<T> createJoin(List<Stage<?>> stages, Function8<T0, T1, T2, T3, T4, T5, T6, T7, T> constructor, TableIdentifier<T0> t0, TableIdentifier<T1> t1, TableIdentifier<T2> t2, TableIdentifier<T3> t3, TableIdentifier<T4> t4, TableIdentifier<T5> t5, TableIdentifier<T6> t6, TableIdentifier<T7> t7) {
return inner.createJoin(stages, constructor, t0, t1, t2, t3, t4, t5, t6, t7);
}
@Override
public <T0, T1, T2, T3, T4, T5, T6, T7, T8, T> Join<T> createJoin(List<Stage<?>> stages, Function9<T0, T1, T2, T3, T4, T5, T6, T7, T8, T> constructor, TableIdentifier<T0> t0, TableIdentifier<T1> t1, TableIdentifier<T2> t2, TableIdentifier<T3> t3, TableIdentifier<T4> t4, TableIdentifier<T5> t5, TableIdentifier<T6> t6, TableIdentifier<T7> t7, TableIdentifier<T8> t8) {
return inner.createJoin(stages, constructor, t0, t1, t2, t3, t4, t5, t6, t7, t8);
}
@Override
public <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T> Join<T> createJoin(List<Stage<?>> stages, Function10<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T> constructor, TableIdentifier<T0> t0, TableIdentifier<T1> t1, TableIdentifier<T2> t2, TableIdentifier<T3> t3, TableIdentifier<T4> t4, TableIdentifier<T5> t5, TableIdentifier<T6> t6, TableIdentifier<T7> t7, TableIdentifier<T8> t8, TableIdentifier<T9> t9) {<FILL_FUNCTION_BODY>}
}
|
return inner.createJoin(stages, constructor, t0, t1, t2, t3, t4, t5, t6, t7, t8, t9);
| 1,559
| 46
| 1,605
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-typemapper/src/main/java/com/speedment/runtime/typemapper/integer/DateIntToPrimitiveShortMapper.java
|
DateIntToPrimitiveShortMapper
|
toJavaType
|
class DateIntToPrimitiveShortMapper implements TypeMapper<Integer, Short> {
@Override
public String getLabel() {
return "Date Integer to short (primitive)";
}
@Override
public Type getJavaType(Column column) {
return short.class;
}
@Override
public Short toJavaType(Column column, Class<?> entityType, Integer date) {<FILL_FUNCTION_BODY>}
@Override
public Integer toDatabaseType(Short value) {
if (value == null) return null;
final LocalDate date = LocalDate.ofEpochDay(value);
return date.getYear() * 10_000 + date.getMonthValue() * 100 + date.getDayOfMonth();
}
}
|
if (date == null) return null;
final int day = date % 100;
final int month = (date % 10_000 - day) / 100;
final int year = date / 10_000;
final LocalDate localDate = LocalDate.of(year, month, day);
return (short) ChronoUnit.DAYS.between(localDate, LocalDate.of(1970, 1,1));
| 200
| 123
| 323
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-typemapper/src/main/java/com/speedment/runtime/typemapper/integer/IntegerToByteMapper.java
|
IntegerToByteMapper
|
toJavaType
|
class IntegerToByteMapper implements TypeMapper<Integer, Byte> {
@Override
public String getLabel() {
return "Integer to Byte";
}
@Override
public Type getJavaType(Column column) {
return Byte.class;
}
@Override
public Byte toJavaType(Column column, Class<?> entityType, Integer value) {<FILL_FUNCTION_BODY>}
@Override
public Integer toDatabaseType(Byte value) {
return value == null ? null : ((int) (byte) value);
}
@Override
public Ordering getOrdering() {
return Ordering.RETAIN;
}
}
|
return value == null ? null : ((byte) (int) value);
| 174
| 20
| 194
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-typemapper/src/main/java/com/speedment/runtime/typemapper/integer/IntegerToShortMapper.java
|
IntegerToShortMapper
|
toDatabaseType
|
class IntegerToShortMapper implements TypeMapper<Integer, Short> {
@Override
public String getLabel() {
return "Integer to Short";
}
@Override
public Type getJavaType(Column column) {
return Short.class;
}
@Override
public Short toJavaType(Column column, Class<?> entityType, Integer value) {
return value == null ? null : ((short) (int) value);
}
@Override
public Integer toDatabaseType(Short value) {<FILL_FUNCTION_BODY>}
@Override
public Ordering getOrdering() {
return Ordering.RETAIN;
}
}
|
return value == null ? null : ((int) (short) value);
| 175
| 20
| 195
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-typemapper/src/main/java/com/speedment/runtime/typemapper/integer/IntegerZeroOneToBooleanMapper.java
|
IntegerZeroOneToBooleanMapper
|
toDatabaseType
|
class IntegerZeroOneToBooleanMapper implements TypeMapper<Integer, Boolean> {
@Override
public String getLabel() {
return "Integer (0|1) to Boolean";
}
@Override
public Type getJavaType(Column column) {
if (column.isNullable()) {
return Boolean.class;
} else {
return boolean.class;
}
}
@Override
public Boolean toJavaType(Column column, Class<?> entityType, Integer value) {
return value == null ? null : value != 0;
}
@Override
public Integer toDatabaseType(Boolean value) {<FILL_FUNCTION_BODY>}
}
|
if (value == null) {
return null;
} else {
return (value ? 1 : 0);
}
| 174
| 37
| 211
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-typemapper/src/main/java/com/speedment/runtime/typemapper/integer/PrimitiveIntegerToByteMapper.java
|
PrimitiveIntegerToByteMapper
|
toJavaType
|
class PrimitiveIntegerToByteMapper implements TypeMapper<Integer, Byte> {
@Override
public String getLabel() {
return "Integer to byte (primitive)";
}
@Override
public Type getJavaType(Column column) {
return byte.class;
}
@Override
public Byte toJavaType(Column column, Class<?> entityType, Integer value) {<FILL_FUNCTION_BODY>}
@Override
public Integer toDatabaseType(Byte value) {
return value == null ? null : ((int) (byte) value);
}
@Override
public Ordering getOrdering() {
return Ordering.RETAIN;
}
}
|
return value == null ? null : ((byte) (int) value);
| 180
| 20
| 200
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-typemapper/src/main/java/com/speedment/runtime/typemapper/integer/PrimitiveIntegerZeroOneToBooleanMapper.java
|
PrimitiveIntegerZeroOneToBooleanMapper
|
toJavaType
|
class PrimitiveIntegerZeroOneToBooleanMapper
implements TypeMapper<Integer, Boolean> {
@Override
public String getLabel() {
return "Integer (0|1) to boolean (primitive)";
}
@Override
public Type getJavaType(Column column) {
return boolean.class;
}
@Override
public Boolean toJavaType(Column column, Class<?> entityType, Integer value) {<FILL_FUNCTION_BODY>}
@Override
public Integer toDatabaseType(Boolean value) {
if (value == null) {
return null;
} else {
return value ? 1 : 0;
}
}
@Override
public Ordering getOrdering() {
return Ordering.RETAIN;
}
}
|
return value == null ? null : value != 0;
| 204
| 17
| 221
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-typemapper/src/main/java/com/speedment/runtime/typemapper/internal/largeobject/StringClob.java
|
StringClob
|
position
|
class StringClob implements Clob {
private String inner;
public StringClob(String inner) {
this.inner = requireNonNull(inner);
}
@Override
public long length() throws SQLException {
assertNotFreeNotCalled();
return inner.length();
}
@Override
public String getSubString(final long ordinalPosition, final int len) throws SQLException {
assertNotFreeNotCalled();
if (inner.isEmpty()) {
return inner;
}
assertInRange(ordinalPosition);
final int effectiveLen;
if (len > inner.length() - ordinalPosition + 1) {
// Truncate length
effectiveLen = (int) (inner.length() - ordinalPosition + 1);
} else {
effectiveLen = len;
}
return inner.substring((int) ordinalPosition - 1, effectiveLen);
}
@Override
public Reader getCharacterStream() throws SQLException {
assertNotFreeNotCalled();
return new StringReader(inner);
}
@Override
public InputStream getAsciiStream() throws SQLException {
assertNotFreeNotCalled();
return new ByteArrayInputStream(inner.getBytes(StandardCharsets.US_ASCII));
}
@Override
public long position(final String str, final long startOrdinalPosition) throws SQLException {<FILL_FUNCTION_BODY>}
@Override
public long position(final Clob clob, final long start) throws SQLException {
requireNonNull(clob);
assertNotFreeNotCalled();
return position(clob.getSubString(1, (int) clob.length()), start);
}
@Override
public int setString(final long pos, final String str) throws SQLException {
assertNotFreeNotCalled();
throw newSQLFeatureNotSupportedException();
}
@Override
public int setString(long pos, String str, int offset, int len) throws SQLException {
assertNotFreeNotCalled();
throw newSQLFeatureNotSupportedException();
}
@Override
public OutputStream setAsciiStream(long pos) throws SQLException {
assertNotFreeNotCalled();
throw newSQLFeatureNotSupportedException();
}
@Override
public Writer setCharacterStream(long ordinalPosition) throws SQLException {
assertNotFreeNotCalled();
assertInRange(ordinalPosition);
throw newSQLFeatureNotSupportedException();
}
@Override
public void truncate(long len) throws SQLException {
assertNotFreeNotCalled();
throw newSQLFeatureNotSupportedException();
}
private SQLFeatureNotSupportedException newSQLFeatureNotSupportedException() {
return new SQLFeatureNotSupportedException("Not supported for an unmodifiable Clob.");
}
@Override
public void free() throws SQLException {
inner = null;
}
@Override
public Reader getCharacterStream(long pos, long length) throws SQLException {
assertNotFreeNotCalled();
if (length > Integer.MAX_VALUE) {
throw new SQLException("Length cannot be >" + Integer.MAX_VALUE);
}
return new StringReader(getSubString(pos, (int) length));
}
private void assertNotFreeNotCalled() throws SQLException {
if (inner == null) {
throw new SQLException("The method free() was already called on this Clob");
}
}
private void assertInRange(long ordinalPosition) throws SQLException {
if (ordinalPosition > inner.length() || ordinalPosition < 1) {
throw new SQLException("Starting position cannot be < 1 or >" + inner.length());
}
}
}
|
assertNotFreeNotCalled();
assertInRange(startOrdinalPosition);
final int index = inner.indexOf(str, (int) startOrdinalPosition - 1);
return (index == -1) ? (-1) : (index + 1);
| 948
| 67
| 1,015
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-typemapper/src/main/java/com/speedment/runtime/typemapper/largeobject/BlobToByteArrayMapper.java
|
BlobToByteArrayMapper
|
toJavaType
|
class BlobToByteArrayMapper implements TypeMapper<Blob, byte[]> {
@Override
public String getLabel() {
return "Blob to byte Array";
}
@Override
public Type getJavaType(Column column) {
return byte[].class;
}
@Override
public byte[] toJavaType(Column column, Class<?> entityType, Blob value) {<FILL_FUNCTION_BODY>}
@Override
public Blob toDatabaseType(byte[] value) {
if (value == null) {
return null;
}
return new StandardBlob(value);
}
}
|
if (value == null) {
return null;
} else try {
if (value.length() < Integer.MAX_VALUE) {
return value.getBytes(1, (int) value.length());
} else {
throw new SpeedmentTypeMapperException(
"The provided Blob contains too many characters >" + Integer.MAX_VALUE
);
}
} catch (final SQLException sqle) {
throw new SpeedmentTypeMapperException("Unable to convert Blob to byte[].", sqle);
}
| 166
| 134
| 300
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-typemapper/src/main/java/com/speedment/runtime/typemapper/longs/LongToByteMapper.java
|
LongToByteMapper
|
toDatabaseType
|
class LongToByteMapper implements TypeMapper<Long, Byte> {
@Override
public String getLabel() {
return "Long to Byte";
}
@Override
public Type getJavaType(Column column) {
return Byte.class;
}
@Override
public Byte toJavaType(Column column, Class<?> entityType, Long value) {
return value == null ? null : ((byte) (long) value);
}
@Override
public Long toDatabaseType(Byte value) {<FILL_FUNCTION_BODY>}
@Override
public Ordering getOrdering() {
return Ordering.RETAIN;
}
}
|
return value == null ? null : ((long) (byte) value);
| 174
| 20
| 194
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-typemapper/src/main/java/com/speedment/runtime/typemapper/longs/LongToIntegerMapper.java
|
LongToIntegerMapper
|
toDatabaseType
|
class LongToIntegerMapper implements TypeMapper<Long, Integer> {
@Override
public String getLabel() {
return "Long to Integer";
}
@Override
public Type getJavaType(Column column) {
return Integer.class;
}
@Override
public Integer toJavaType(Column column, Class<?> entityType, Long value) {
return value == null ? null : ((int) (long) value);
}
@Override
public Long toDatabaseType(Integer value) {<FILL_FUNCTION_BODY>}
@Override
public Ordering getOrdering() {
return Ordering.RETAIN;
}
}
|
return value == null ? null : ((long) (int) value);
| 174
| 20
| 194
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-typemapper/src/main/java/com/speedment/runtime/typemapper/longs/PrimitiveLongToByteMapper.java
|
PrimitiveLongToByteMapper
|
toDatabaseType
|
class PrimitiveLongToByteMapper implements TypeMapper<Long, Byte> {
@Override
public String getLabel() {
return "Long to byte (primitive)";
}
@Override
public Type getJavaType(Column column) {
return byte.class;
}
@Override
public Byte toJavaType(Column column, Class<?> entityType, Long value) {
return value == null ? null : (byte) (long) value;
}
@Override
public Long toDatabaseType(Byte value) {<FILL_FUNCTION_BODY>}
@Override
public Ordering getOrdering() {
return Ordering.RETAIN;
}
}
|
return value == null ? null : (long) (byte) value;
| 180
| 20
| 200
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-typemapper/src/main/java/com/speedment/runtime/typemapper/longs/PrimitiveLongToIntegerMapper.java
|
PrimitiveLongToIntegerMapper
|
toJavaType
|
class PrimitiveLongToIntegerMapper implements TypeMapper<Long, Integer> {
@Override
public String getLabel() {
return "Long to int (primitive)";
}
@Override
public Type getJavaType(Column column) {
return int.class;
}
@Override
public Integer toJavaType(Column column, Class<?> entityType, Long value) {<FILL_FUNCTION_BODY>}
@Override
public Long toDatabaseType(Integer value) {
return value == null ? null : ((long) (int) value);
}
@Override
public Ordering getOrdering() {
return Ordering.RETAIN;
}
}
|
return value == null ? null : ((int) (long) value);
| 180
| 20
| 200
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-typemapper/src/main/java/com/speedment/runtime/typemapper/longs/PrimitiveLongToShortMapper.java
|
PrimitiveLongToShortMapper
|
toDatabaseType
|
class PrimitiveLongToShortMapper implements TypeMapper<Long, Short> {
@Override
public String getLabel() {
return "Long to short (primitive)";
}
@Override
public Type getJavaType(Column column) {
return short.class;
}
@Override
public Short toJavaType(Column column, Class<?> entityType, Long value) {
return value == null ? null : ((short) (long) value);
}
@Override
public Long toDatabaseType(Short value) {<FILL_FUNCTION_BODY>}
@Override
public Ordering getOrdering() {
return Ordering.RETAIN;
}
}
|
return value == null ? null : ((long) (short) value);
| 180
| 20
| 200
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-typemapper/src/main/java/com/speedment/runtime/typemapper/other/BinaryToBigIntegerMapper.java
|
BinaryToBigIntegerMapper
|
toDatabaseType
|
class BinaryToBigIntegerMapper
implements TypeMapper<Object, BigInteger> {
@Override
public String getLabel() {
return "BINARY to BigInteger Mapper";
}
@Override
public Type getJavaType(Column column) {
return BigInteger.class;
}
@Override
public Category getJavaTypeCategory(Column column) {
return Category.COMPARABLE;
}
@Override
public BigInteger toJavaType(Column column, Class<?> entityType, Object value) {
if (value == null) return null;
try {
final byte[] bytes = (byte[]) value;
return new BigInteger(bytes);
} catch (final ClassCastException ex) {
throw new SpeedmentTypeMapperException(format(
"Expected input type to be a byte[], but was %s.",
value.getClass().getName()), ex);
}
}
@Override
public Object toDatabaseType(BigInteger value) {<FILL_FUNCTION_BODY>}
@Override
public Ordering getOrdering() {
return Ordering.UNSPECIFIED;
}
}
|
if (value == null) return null;
else return value.toByteArray();
| 294
| 24
| 318
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-typemapper/src/main/java/com/speedment/runtime/typemapper/primitive/PrimitiveTypeMapper.java
|
PrimitiveTypeMapper
|
getJavaType
|
class PrimitiveTypeMapper<T> implements TypeMapper<T, T> {
@Override
public String getLabel() {
return "(To Primitive)";
}
@Override
public Type getJavaType(Column column) {<FILL_FUNCTION_BODY>}
@Override
public T toJavaType(Column column, Class<?> entityType, T value) {
return value;
}
@Override
public T toDatabaseType(T value) {
return value;
}
@Override
public Ordering getOrdering() {
return Ordering.RETAIN;
}
}
|
final String type = column.getDatabaseType();
switch (type) {
case "java.lang.Byte" : return byte.class;
case "java.lang.Short" : return short.class;
case "java.lang.Integer" : return int.class;
case "java.lang.Long" : return long.class;
case "java.lang.Float" : return float.class;
case "java.lang.Double" : return double.class;
case "java.lang.Boolean" : return boolean.class;
case "java.lang.Character" : return char.class;
default : throw new UnsupportedOperationException(
"Type " + type + " is not a wrapper for a primitive type."
);
}
| 165
| 192
| 357
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-typemapper/src/main/java/com/speedment/runtime/typemapper/shorts/PrimitiveShortToByteMapper.java
|
PrimitiveShortToByteMapper
|
toDatabaseType
|
class PrimitiveShortToByteMapper implements TypeMapper<Short, Byte> {
@Override
public String getLabel() {
return "Short to byte (primitive)";
}
@Override
public Type getJavaType(Column column) {
return byte.class;
}
@Override
public Byte toJavaType(Column column, Class<?> entityType, Short value) {
return value == null ? null : ((byte) (short) value);
}
@Override
public Short toDatabaseType(Byte value) {<FILL_FUNCTION_BODY>}
@Override
public Ordering getOrdering() {
return Ordering.RETAIN;
}
}
|
return value == null ? null : ((short) (byte) value);
| 180
| 20
| 200
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-typemapper/src/main/java/com/speedment/runtime/typemapper/shorts/ShortToByteMapper.java
|
ShortToByteMapper
|
toJavaType
|
class ShortToByteMapper implements TypeMapper<Short, Byte> {
@Override
public String getLabel() {
return "Short to Byte";
}
@Override
public Type getJavaType(Column column) {
return Byte.class;
}
@Override
public Byte toJavaType(Column column, Class<?> entityType, Short value) {<FILL_FUNCTION_BODY>}
@Override
public Short toDatabaseType(Byte value) {
return value == null ? null : ((short) (byte) value);
}
@Override
public Ordering getOrdering() {
return Ordering.RETAIN;
}
}
|
return value == null ? null : ((byte) (short) value);
| 174
| 20
| 194
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-typemapper/src/main/java/com/speedment/runtime/typemapper/string/StringToBigIntegerMapper.java
|
StringToBigIntegerMapper
|
toJavaType
|
class StringToBigIntegerMapper
implements TypeMapper<String, BigInteger> {
@Override
public String getLabel() {
return "String to BigInteger Mapper";
}
@Override
public Type getJavaType(Column column) {
return BigInteger.class;
}
@Override
public Category getJavaTypeCategory(Column column) {
return Category.COMPARABLE;
}
@Override
public BigInteger toJavaType(Column column, Class<?> entityType, String value) {<FILL_FUNCTION_BODY>}
@Override
public String toDatabaseType(BigInteger value) {
return value == null ? null : value.toString();
}
@Override
public Ordering getOrdering() {
// Alphabetic order and numeric order might differ
return Ordering.UNSPECIFIED;
}
}
|
return value == null ? null : new BigInteger(value);
| 225
| 18
| 243
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-typemapper/src/main/java/com/speedment/runtime/typemapper/string/TrueFalseStringToBooleanMapper.java
|
TrueFalseStringToBooleanMapper
|
getJavaType
|
class TrueFalseStringToBooleanMapper implements TypeMapper<String, Boolean> {
@Override
public String getLabel() {
return "True/False to Boolean";
}
@Override
public Type getJavaType(Column column) {<FILL_FUNCTION_BODY>}
@Override
public Boolean toJavaType(Column column, Class<?> entityType, String value) {
return value == null ? null : Boolean.valueOf(value);
}
@Override
public String toDatabaseType(Boolean value) {
return value == null ? null : String.valueOf(value);
}
}
|
if (column.isNullable()) {
return Boolean.class;
} else {
return boolean.class;
}
| 158
| 35
| 193
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-typemapper/src/main/java/com/speedment/runtime/typemapper/string/YNStringToBooleanMapper.java
|
YNStringToBooleanMapper
|
toDatabaseType
|
class YNStringToBooleanMapper implements TypeMapper<String, Boolean> {
@Override
public String getLabel() {
return "Y/N to Boolean";
}
@Override
public Type getJavaType(Column column) {
if (column.isNullable()) {
return Boolean.class;
} else {
return boolean.class;
}
}
@Override
public Boolean toJavaType(Column column, Class<?> entityType, String value) {
return value == null ? null : value.equalsIgnoreCase("Y");
}
@Override
public String toDatabaseType(Boolean value) {<FILL_FUNCTION_BODY>}
}
|
if (value == null) {
return null;
} else {
return value ? "Y" : "N";
}
| 174
| 37
| 211
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-typemapper/src/main/java/com/speedment/runtime/typemapper/string/YesNoStringToBooleanMapper.java
|
YesNoStringToBooleanMapper
|
toDatabaseType
|
class YesNoStringToBooleanMapper implements TypeMapper<String, Boolean> {
@Override
public String getLabel() {
return "Yes/No to Boolean";
}
@Override
public Type getJavaType(Column column) {
if (column.isNullable()) {
return Boolean.class;
} else {
return boolean.class;
}
}
@Override
public Boolean toJavaType(Column column, Class<?> entityType, String value) {
return value == null ? null : value.equalsIgnoreCase("yes");
}
@Override
public String toDatabaseType(Boolean value) {<FILL_FUNCTION_BODY>}
}
|
if (value == null) {
return null;
} else {
return value ? "yes" : "no";
}
| 174
| 37
| 211
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-typemapper/src/main/java/com/speedment/runtime/typemapper/time/DateToLongMapper.java
|
DateToLongMapper
|
toDatabaseType
|
class DateToLongMapper implements TypeMapper<Date, Long> {
@Override
public String getLabel() {
return "Date to Long";
}
@Override
public Type getJavaType(Column column) {
return Long.class;
}
@Override
public Long toJavaType(Column column, Class<?> entityType, Date value) {
return value == null ? null : value.getTime();
}
@Override
public Date toDatabaseType(Long value) {<FILL_FUNCTION_BODY>}
@Override
public Ordering getOrdering() {
return Ordering.RETAIN;
}
}
|
return value == null ? null : new Date(value);
| 173
| 17
| 190
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-typemapper/src/main/java/com/speedment/runtime/typemapper/time/IntEpochDaysToLocalDateMapper.java
|
IntEpochDaysToLocalDateMapper
|
toDatabaseType
|
class IntEpochDaysToLocalDateMapper
implements TypeMapper<Integer, LocalDate> {
@Override
public String getLabel() {
return "Int (Epoch Day) to LocalDate";
}
@Override
public Type getJavaType(Column column) {
return LocalDate.class;
}
@Override
public LocalDate toJavaType(Column column, Class<?> entityType, Integer value) {
return value == null ? null : LocalDate.ofEpochDay(value);
}
@Override
public Integer toDatabaseType(LocalDate value) {<FILL_FUNCTION_BODY>}
@Override
public Ordering getOrdering() {
return Ordering.RETAIN;
}
}
|
return value == null ? null : (int) value.toEpochDay();
| 191
| 22
| 213
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-typemapper/src/main/java/com/speedment/runtime/typemapper/time/ShortEpochDaysToLocalDateMapper.java
|
ShortEpochDaysToLocalDateMapper
|
toDatabaseType
|
class ShortEpochDaysToLocalDateMapper
implements TypeMapper<Short, LocalDate> {
@Override
public String getLabel() {
return "Short (Epoch Day) to LocalDate";
}
@Override
public Type getJavaType(Column column) {
return LocalDate.class;
}
@Override
public LocalDate toJavaType(Column column, Class<?> entityType, Short value) {
return value == null ? null : LocalDate.ofEpochDay(value);
}
@Override
public Short toDatabaseType(LocalDate value) {<FILL_FUNCTION_BODY>}
@Override
public Ordering getOrdering() {
return Ordering.RETAIN;
}
}
|
return value == null ? null : (short) value.toEpochDay();
| 191
| 22
| 213
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-typemapper/src/main/java/com/speedment/runtime/typemapper/time/TimeToIntMapper.java
|
TimeToIntMapper
|
toDatabaseType
|
class TimeToIntMapper implements TypeMapper<Time, Integer> {
@Override
public String getLabel() {
return "Time to Integer";
}
@Override
public Type getJavaType(Column column) {
return Integer.class;
}
@Override
public Integer toJavaType(Column column, Class<?> entityType, Time value) {
return value == null ? null : (int) (value.getTime() / 1000);
}
@Override
public Time toDatabaseType(Integer value) {<FILL_FUNCTION_BODY>}
@Override
public Ordering getOrdering() {
return Ordering.RETAIN;
}
}
|
return value == null ? null : new Time(value * 1000L);
| 184
| 24
| 208
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-typemapper/src/main/java/com/speedment/runtime/typemapper/time/TimeToPrimitiveIntMapper.java
|
TimeToPrimitiveIntMapper
|
toJavaType
|
class TimeToPrimitiveIntMapper implements TypeMapper<Time, Integer> {
@Override
public String getLabel() {
return "Time to int";
}
@Override
public Type getJavaType(Column column) {
return int.class;
}
@Override
public Integer toJavaType(Column column, Class<?> entityType, Time value) {<FILL_FUNCTION_BODY>}
@Override
public Time toDatabaseType(Integer value) {
return value == null ? null : new Time(value * 1000L);
}
@Override
public Ordering getOrdering() {
return Ordering.RETAIN;
}
}
|
return value == null ? null : (int) (value.getTime() / 1000);
| 182
| 28
| 210
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-typemapper/src/main/java/com/speedment/runtime/typemapper/time/TimestampToLongMapper.java
|
TimestampToLongMapper
|
toDatabaseType
|
class TimestampToLongMapper implements TypeMapper<Timestamp, Long> {
@Override
public String getLabel() {
return "Timestamp to Long";
}
@Override
public Type getJavaType(Column column) {
return Long.class;
}
@Override
public Long toJavaType(Column column, Class<?> entityType, Timestamp value) {
return value == null ? null : value.getTime();
}
@Override
public Timestamp toDatabaseType(Long value) {<FILL_FUNCTION_BODY>}
@Override
public Ordering getOrdering() {
return Ordering.RETAIN;
}
}
|
return value == null ? null : new Timestamp(value);
| 175
| 18
| 193
|
<no_super_class>
|
speedment_speedment
|
speedment/runtime-parent/runtime-typemapper/src/main/java/com/speedment/runtime/typemapper/time/TimestampToPrimitiveIntMapper.java
|
TimestampToPrimitiveIntMapper
|
toJavaType
|
class TimestampToPrimitiveIntMapper implements TypeMapper<Timestamp, Integer> {
@Override
public String getLabel() {
return "Timestamp to int";
}
@Override
public Type getJavaType(Column column) {
return int.class;
}
@Override
public Integer toJavaType(Column column, Class<?> entityType, Timestamp value) {<FILL_FUNCTION_BODY>}
@Override
public Timestamp toDatabaseType(Integer value) {
return value == null ? null : new Timestamp(value * 1000L);
}
@Override
public Ordering getOrdering() {
return Ordering.RETAIN;
}
}
|
return value == null ? null : (int) (value.getTime() / 1000);
| 184
| 28
| 212
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-actions/src/main/java/com/speedment/tool/actions/internal/menues/ToggleColumnsEnabledActionImpl.java
|
ToggleColumnsEnabledActionImpl
|
installMenuItems
|
class ToggleColumnsEnabledActionImpl
implements AbstractToolAction, ToggleColumnsEnabledAction {
static final String ENABLE_ALL_COLUMNS = "Enable All Columns";
static final String DISABLE_ALL_COLUMNS = "Disable All Columns";
@Override
public void installMenuItems(ProjectTreeComponent projectTree) {<FILL_FUNCTION_BODY>}
}
|
projectTree.installContextMenu(TableProperty.class, (treeCell, node) -> {
final MenuItem enableColumns = new MenuItem(ENABLE_ALL_COLUMNS);
final MenuItem disableColumns = new MenuItem(DISABLE_ALL_COLUMNS);
enableColumns.setOnAction(ev ->
DocumentUtil.traverseOver(node)
.filter(ColumnProperty.class::isInstance)
.forEach(doc -> ((ColumnProperty) doc).enabledProperty().setValue(true))
);
disableColumns.setOnAction(ev ->
DocumentUtil.traverseOver(node)
.filter(ColumnProperty.class::isInstance)
.forEach(doc -> ((ColumnProperty) doc).enabledProperty().setValue(false))
);
return Stream.of(enableColumns, disableColumns);
});
| 97
| 208
| 305
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-actions/src/main/java/com/speedment/tool/actions/internal/menues/ToggleExpandedActionImpl.java
|
ToggleExpandedActionImpl
|
installForDocumentType
|
class ToggleExpandedActionImpl
implements AbstractToolAction, ToggleExpandedAction {
static final String EXPAND_ALL = "Expand All";
static final String COLLAPSE_ALL = "Collapse All";
@Override
public void installMenuItems(ProjectTreeComponent projectTree) {
projectTree.installContextMenu(DbmsProperty.class, this::installForDocumentType);
projectTree.installContextMenu(SchemaProperty.class, this::installForDocumentType);
projectTree.installContextMenu(TableProperty.class, this::installForDocumentType);
}
private <DOC extends DocumentProperty> Stream<MenuItem>
installForDocumentType(TreeCell<DocumentProperty> treeCell, DOC node) {<FILL_FUNCTION_BODY>}
}
|
final MenuItem expandAll = new MenuItem(EXPAND_ALL, ProjectTreeIcon.BOOK_OPEN.view());
final MenuItem collapseAll = new MenuItem(COLLAPSE_ALL, ProjectTreeIcon.BOOK.view());
expandAll.setOnAction(ev ->
DocumentUtil.traverseOver(node)
.filter(HasExpandedProperty.class::isInstance)
.forEach(doc -> ((HasExpandedProperty) doc).expandedProperty().setValue(true))
);
collapseAll.setOnAction(ev ->
DocumentUtil.traverseOver(node)
.filter(HasExpandedProperty.class::isInstance)
.forEach(doc -> ((HasExpandedProperty) doc).expandedProperty().setValue(false))
);
return Stream.of(expandAll, collapseAll);
| 194
| 209
| 403
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-actions/src/main/java/com/speedment/tool/actions/internal/menues/ToggleTablesEnabledActionImpl.java
|
ToggleTablesEnabledActionImpl
|
installMenuItems
|
class ToggleTablesEnabledActionImpl
implements AbstractToolAction, ToggleTablesEnabledAction {
static final String ENABLE_ALL_TABLES = "Enable All Tables";
static final String DISABLE_ALL_TABLES = "Disable All Tables";
@Override
public void installMenuItems(ProjectTreeComponent projectTree) {<FILL_FUNCTION_BODY>}
}
|
projectTree.installContextMenu(SchemaProperty.class, (treeCell, node) -> {
final MenuItem enableTables = new MenuItem(ENABLE_ALL_TABLES);
final MenuItem disableTables = new MenuItem(DISABLE_ALL_TABLES);
enableTables.setOnAction(ev ->
DocumentUtil.traverseOver(node)
.filter(TableProperty.class::isInstance)
.forEach(doc -> ((TableProperty) doc).enabledProperty().setValue(true))
);
disableTables.setOnAction(ev ->
DocumentUtil.traverseOver(node)
.filter(TableProperty.class::isInstance)
.forEach(doc -> ((TableProperty) doc).enabledProperty().setValue(false))
);
return Stream.of(enableTables, disableTables);
});
| 97
| 212
| 309
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-config/src/main/java/com/speedment/tool/config/ForeignKeyColumnProperty.java
|
ForeignKeyColumnProperty
|
foreignColumnProperty
|
class ForeignKeyColumnProperty extends AbstractChildDocumentProperty<ForeignKey, ForeignKeyColumnProperty>
implements ForeignKeyColumn,
HasExpandedProperty,
HasIdProperty,
HasNameProperty,
HasOrdinalPositionProperty,
HasColumnProperty,
HasNameProtectedProperty {
public final StringProperty foreignDatabaseNameProperty() {
return stringPropertyOf(ForeignKeyColumnUtil.FOREIGN_DATABASE_NAME, ForeignKeyColumn.super::getForeignDatabaseName);
}
@Override
public String getForeignDatabaseName() {
return foreignDatabaseNameProperty().get();
}
public final StringProperty foreignSchemaNameProperty() {
return stringPropertyOf(ForeignKeyColumnUtil.FOREIGN_SCHEMA_NAME, ForeignKeyColumn.super::getForeignSchemaName);
}
@Override
public String getForeignSchemaName() {
return foreignSchemaNameProperty().get();
}
public ForeignKeyColumnProperty(ForeignKey parent) {
super(parent);
}
public final StringProperty foreignTableNameProperty() {
return stringPropertyOf(ForeignKeyColumnUtil.FOREIGN_TABLE_NAME, ForeignKeyColumn.super::getForeignTableName);
}
@Override
public String getForeignTableName() {
return foreignTableNameProperty().get();
}
public final StringProperty foreignColumnNameProperty() {
return stringPropertyOf(ForeignKeyColumnUtil.FOREIGN_COLUMN_NAME, ForeignKeyColumn.super::getForeignColumnName);
}
@Override
public String getForeignColumnName() {
return foreignColumnNameProperty().get();
}
public final ObjectBinding<TableProperty> foreignTableProperty() {
return createObjectBinding(
() -> ForeignKeyColumn.super.findForeignTable()
.map(TableProperty.class::cast)
.orElse(null),
foreignTableNameProperty()
);
}
@Override
public Optional<TableProperty> findForeignTable() {
return Optional.ofNullable(foreignTableProperty().get());
}
public final ObjectBinding<ColumnProperty> foreignColumnProperty() {<FILL_FUNCTION_BODY>}
@Override
public Optional<ColumnProperty> findForeignColumn() {
return Optional.ofNullable(foreignColumnProperty().get());
}
@Override
public ForeignKeyColumnPropertyMutator mutator() {
return DocumentPropertyMutator.of(this);
}
@Override
protected List<String> keyPathEndingWith(String key) {
return concat(DocumentPropertyComponentUtil.FOREIGN_KEY_COLUMNS, key);
}
}
|
return createObjectBinding(
() -> ForeignKeyColumn.super.findForeignColumn()
.map(ColumnProperty.class::cast)
.orElse(null),
foreignTableNameProperty(),
foreignColumnNameProperty()
);
| 679
| 65
| 744
|
<methods>public void <init>(com.speedment.runtime.config.ForeignKey) ,public final Optional<com.speedment.runtime.config.ForeignKey> getParent() <variables>private final non-sealed com.speedment.runtime.config.ForeignKey parent
|
speedment_speedment
|
speedment/tool-parent/tool-config/src/main/java/com/speedment/tool/config/internal/component/DocumentPropertyComponentImpl.java
|
Branch
|
find
|
class Branch {
private final ConstructorHolder holder;
private final Map<String, Branch> children;
private Branch(Constructor<?> constructor) {
this.holder = new ConstructorHolder(constructor);
this.children = new ConcurrentHashMap<>();
}
public ConstructorHolder find(List<String> keyPath) {
return find(0, keyPath);
}
private ConstructorHolder find(int i, List<String> keyPath) {<FILL_FUNCTION_BODY>}
@Override
public String toString() {
return children.toString();
}
}
|
// If we are at the last key, return our constructor.
if (i == keyPath.size()) {
return holder;
// If there are still keys in the path, find the one mentioned in
// the i:th key and recurse into that branch
} else if (i < keyPath.size()) {
return children.computeIfAbsent(
keyPath.get(i), k -> new Branch(parent -> {
final AbstractDocumentProperty<?> castedParent
= (AbstractDocumentProperty<?>) parent;
return new DefaultDocumentProperty(castedParent, k);
})
).find(i + 1, keyPath);
// If we are out of keys, something is terrible wrong...
} else {
throw new UnsupportedOperationException(
"iterator is outside the specified keyPath."
);
}
| 159
| 212
| 371
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-config/src/main/java/com/speedment/tool/config/mutator/ForeignKeyPropertyMutator.java
|
ForeignKeyPropertyMutator
|
addNewForeignKeyColumn
|
class ForeignKeyPropertyMutator extends ForeignKeyMutator<ForeignKeyProperty> implements
HasEnabledPropertyMutator<ForeignKeyProperty>,
HasNamePropertyMutator<ForeignKeyProperty> {
ForeignKeyPropertyMutator(ForeignKeyProperty foreignKey) {
super(foreignKey);
}
@Override
public ForeignKeyColumnProperty addNewForeignKeyColumn() {<FILL_FUNCTION_BODY>}
}
|
final ForeignKeyColumnProperty child = new ForeignKeyColumnProperty(document());
document().foreignKeyColumnsProperty().add(child);
return child;
| 111
| 39
| 150
|
<methods>public void <init>(com.speedment.tool.config.ForeignKeyProperty) ,public com.speedment.runtime.config.ForeignKeyColumn addNewForeignKeyColumn() <variables>
|
speedment_speedment
|
speedment/tool-parent/tool-config/src/main/java/com/speedment/tool/config/mutator/IndexPropertyMutator.java
|
IndexPropertyMutator
|
addNewIndexColumn
|
class IndexPropertyMutator extends IndexMutator<IndexProperty> implements
HasEnabledPropertyMutator<IndexProperty>,
HasNamePropertyMutator<IndexProperty> {
IndexPropertyMutator(IndexProperty index) {
super(index);
}
@Override
public void setUnique(Boolean unique) {
document().uniqueProperty().setValue(unique);
}
@Override
public IndexColumnProperty addNewIndexColumn() {<FILL_FUNCTION_BODY>}
}
|
final IndexColumnProperty child = new IndexColumnProperty(document());
document().indexColumnsProperty().add(child);
return child;
| 126
| 35
| 161
|
<methods>public void <init>(com.speedment.tool.config.IndexProperty) ,public com.speedment.runtime.config.IndexColumn addNewIndexColumn() ,public void setUnique(java.lang.Boolean) <variables>
|
speedment_speedment
|
speedment/tool-parent/tool-core/src/main/java/com/speedment/tool/core/MainApp.java
|
MainApp
|
start
|
class MainApp extends Application {
private static final Logger LOGGER = LoggerManager.getLogger(MainApp.class);
public static void setInjector(Injector injector) {
InjectorHolder.INSTANCE.setInjector(injector);
}
@Override
public void start(Stage stage) {<FILL_FUNCTION_BODY>}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
launch(args);
}
}
|
requireNonNull(stage);
InjectorBuilder.logger().setLevel(DEBUG);
if (InjectorHolder.INSTANCE.getInjector() == null) {
LOGGER.warn("Creating new Speedment instance for UI session.");
final Injector newInjector = new DefaultApplicationBuilder(
getClass().getClassLoader(),
DefaultApplicationMetadata.class
)
.withBundle(GeneratorBundle.class)
.withComponent(ToolBundle.class)
.build().getOrThrow(Injector.class);
InjectorHolder.INSTANCE.setInjector(newInjector);
}
final Injector injector = InjectorHolder.INSTANCE.getInjector();
final UserInterfaceComponentImpl ui = injector.getOrThrow(UserInterfaceComponentImpl.class);
final ProjectComponent projects = injector.getOrThrow(ProjectComponent.class);
final EventComponent events = injector.getOrThrow(EventComponent.class);
final InjectionLoader loader = injector.getOrThrow(InjectionLoader.class);
events.on(UIEvent.class, ev -> {
if (ev == UIEvent.OPEN_MAIN_WINDOW) {
ui.showNotification(
"You are running Speedment Open Source. Click here to " +
"upgrade to Speedment Enterprise.",
FontAwesome.PLUS, Palette.SUCCESS,
() -> ui.browse("https://speedment.com/pricing")
);
}
});
ui.start(this, stage);
if (EmailUtil.hasEmail()) {
if (projects.getProject().dbmses().noneMatch(dbms -> true)) {
loader.loadAndShow("Connect");
stage.setTitle("Connect to database");
} else {
loader.loadAndShow("Scene");
events.notify(UIEvent.OPEN_MAIN_WINDOW);
ui.showNotification(
"Metadata has been loaded from an offline file. Click " +
"here to reload from database.",
FontAwesome.REFRESH,
Palette.INFO,
ui::reload
);
}
} else {
loader.loadAndShow("MailPrompt");
}
| 139
| 570
| 709
|
<methods>public void <init>() ,public final javafx.application.HostServices getHostServices() ,public final javafx.application.Application.Parameters getParameters() ,public static java.lang.String getUserAgentStylesheet() ,public void init() throws java.lang.Exception,public static transient void launch(java.lang.String[]) ,public static transient void launch(Class<? extends javafx.application.Application>, java.lang.String[]) ,public final void notifyPreloader(javafx.application.Preloader.PreloaderNotification) ,public static void setUserAgentStylesheet(java.lang.String) ,public abstract void start(javafx.stage.Stage) throws java.lang.Exception,public void stop() throws java.lang.Exception<variables>public static final java.lang.String STYLESHEET_CASPIAN,public static final java.lang.String STYLESHEET_MODENA,private javafx.application.HostServices hostServices,private static java.lang.String userAgentStylesheet
|
speedment_speedment
|
speedment/tool-parent/tool-core/src/main/java/com/speedment/tool/core/ToolBundle.java
|
ToolBundle
|
injectables
|
class ToolBundle implements InjectBundle {
@Override
public Stream<Class<?>> injectables() {<FILL_FUNCTION_BODY>}
}
|
return InjectBundle.of(UserInterfaceComponentImpl.class)
.withBundle(DelegateUserInterfaceComponent.include())
.withBundle(new ToolActionsBundle())
.withComponent(VersionComponentImpl.class)
.withComponent(RuleComponentImpl.class)
.withComponent(ConfigFileHelper.class)
.withComponent(InjectionLoaderImpl.class)
.withComponent(ToolbarComponentImpl.class)
.withComponent(DefaultToolbarItems.class)
.withComponent(DefaultMenuItemFactories.class)
.withComponent(MenuBarComponentImpl.class)
.injectables();
| 43
| 152
| 195
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-core/src/main/java/com/speedment/tool/core/internal/component/RuleComponentImpl.java
|
RuleComponentImpl
|
verify
|
class RuleComponentImpl implements RuleComponent {
private final List<Rule> rules;
public RuleComponentImpl(
final ProjectComponent projectComponent,
final IssueComponent issues
) {
this.rules = new LinkedList<>();
install(new ProtectedNameRule(projectComponent, issues));
install(new ReferencesEnabledRule(projectComponent, issues));
}
@Override
public void install(Rule rule) {
rules.add(rule);
}
@Override
@SuppressWarnings("unchecked")
public CompletableFuture<Boolean> verify() {<FILL_FUNCTION_BODY>}
}
|
final CompletableFuture<Boolean>[] futures;
futures = rules.stream().parallel()
.map(Rule::verify)
.toArray(CompletableFuture[]::new);
return CompletableFutureUtil.allOf(Boolean.TRUE, Boolean::logicalAnd, futures);
| 161
| 75
| 236
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-core/src/main/java/com/speedment/tool/core/internal/controller/MailPromptController.java
|
MailPromptController
|
initialize
|
class MailPromptController implements Initializable {
private static final Pattern INVALID_MAIL =
Pattern.compile("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,6}$");
private static final Predicate<String> IS_INVALID_MAIL =
mail -> !INVALID_MAIL.matcher(mail).find();
public @Inject ProjectComponent projects;
public @Inject UserInterfaceComponent ui;
public @Inject InjectionLoader loader;
public @Inject EventComponent events;
private @FXML TextField email;
private @FXML TextArea terms;
private @FXML Button okay;
@Override
public void initialize(URL location, ResourceBundle resources) {<FILL_FUNCTION_BODY>}
private static String inputToString(InputStream in) throws IOException {
try (final BufferedInputStream bis = new BufferedInputStream(in)) {
try (final ByteArrayOutputStream buf = new ByteArrayOutputStream()) {
int result = bis.read();
while(result != -1) {
byte b = (byte) result;
buf.write(b);
result = bis.read();
}
return buf.toString();
}
}
}
}
|
okay.setGraphic(FontAwesome.CHECK.view());
okay.disableProperty().bind(Bindings.createBooleanBinding(
() -> IS_INVALID_MAIL.test(email.getText()),
email.textProperty()
));
okay.setOnAction(ev -> {
loader.loadAndShow("Connect");
if (EmailUtil.hasEmail()) {
if (projects.getProject().dbmses().noneMatch(dbms -> true)) {
loader.loadAndShow("Connect");
} else {
loader.loadAndShow("Scene");
ui.showNotification(
"Metadata has been loaded from an offline file. " +
"Click here to reload from database.",
FontAwesome.REFRESH,
Palette.INFO,
ui::reload
);
}
} else {
loader.loadAndShow("MailPrompt");
}
EmailUtil.setEmail(email.getText());
events.notify(UIEvent.OPEN_CONNECT_WINDOW);
});
try {
final InputStream in = MailPromptController.class.getResourceAsStream("/text/terms.txt");
final String str = inputToString(in);
terms.setText(str);
} catch (final IOException ex) {
ui.showError(
"Failed to load file",
"The terms and conditions of this software couldn't be loaded.",
ex
);
}
| 339
| 373
| 712
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-core/src/main/java/com/speedment/tool/core/internal/controller/NotificationAreaController.java
|
NotificationAreaController
|
initialize
|
class NotificationAreaController implements Initializable {
private final LayoutAnimator animator;
public @Inject UserInterfaceComponent userInterfaceComponent;
private @FXML FlowPane notificationArea;
public NotificationAreaController() {
this.animator = new LayoutAnimator();
}
/**
* Initializes the controller class.
*
* @param url the url
* @param rb the resource bundle
*/
@Override
public void initialize(URL url, ResourceBundle rb) {<FILL_FUNCTION_BODY>}
}
|
animator.observe(notificationArea.getChildren());
final ObservableList<Notification> notifications = userInterfaceComponent.notifications();
notifications.addListener((ListChangeListener.Change<? extends Notification> change) -> {
while (change.next()) {
if (change.wasAdded()) {
change.getAddedSubList().forEach(n -> {
NotificationController.showNotification(
notificationArea,
n.text(),
n.icon(),
n.palette(),
n.onClose()
);
notifications.remove(n);
});
}
}
});
while (!notifications.isEmpty()) {
final Notification n = notifications.get(0);
NotificationController.showNotification(
notificationArea,
n.text(),
n.icon(),
n.palette(),
n.onClose()
);
notifications.remove(0);
}
| 151
| 241
| 392
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-core/src/main/java/com/speedment/tool/core/internal/controller/NotificationController.java
|
NotificationController
|
childrenOf
|
class NotificationController implements Initializable {
private static final int ENTER_SPEED = 350;
private static final int EXIT_SPEED = 350;
private static final int ENTER_Y = 100;
private static final String NOTIFICATION_FXML = "/fxml/Notification.fxml";
private static final Duration TIMER = Duration.seconds(10);
private final String message;
private final Icon icon;
private final Palette palette;
private final Runnable onClose;
private final AtomicBoolean destroyed;
@FXML private Label notification;
private NotificationController(
final String message,
final Icon icon,
final Palette palette,
final Runnable onClose
) {
this.message = requireNonNull(message);
this.icon = requireNonNull(icon);
this.palette = requireNonNull(palette);
this.onClose = requireNonNull(onClose);
this.destroyed = new AtomicBoolean(false);
}
/**
* Initializes the controller class.
*/
@Override
public void initialize(URL url, ResourceBundle rb) {
notification.setText(message);
notification.setGraphic(icon.view());
notification.getStyleClass().add(palette.name().toLowerCase());
}
@FXML public void close() {
if (destroyed.compareAndSet(false, true)) {
onClose.run();
remove(notification);
}
}
private void fadeAway() {
final FadeTransition fade = new FadeTransition(millis(EXIT_SPEED), notification);
fade.setFromValue(1);
fade.setToValue(0);
final TranslateTransition trans = new TranslateTransition(millis(EXIT_SPEED), notification);
trans.setFromY(0);
trans.setToY(ENTER_Y);
final SequentialTransition seq = new SequentialTransition(fade, trans);
seq.setOnFinished(ev -> {
if (destroyed.compareAndSet(false, true)) {
remove(notification);
}
});
seq.play();
}
static void showNotification(FlowPane area, String message, Icon icon, Palette palette, Runnable onClose) {
final FXMLLoader loader = new FXMLLoader(NotificationController.class.getResource(NOTIFICATION_FXML));
final AtomicReference<NotificationController> ref = new AtomicReference<>();
loader.setControllerFactory(clazz -> {
ref.set(new NotificationController(message, icon, palette, onClose));
return ref.get();
});
final Node notification;
try {
notification = loader.load();
} catch (final IOException ex) {
throw new SpeedmentToolException(
"Failed to load FXML-file: '" + NOTIFICATION_FXML + "'.", ex
);
}
notification.setOpacity(0);
notification.setLayoutX(area.getWidth());
notification.setLayoutY(area.getHeight());
final FadeTransition fade = new FadeTransition(millis(ENTER_SPEED), notification);
fade.setFromValue(0);
fade.setToValue(1);
runLater(() -> {
childrenOf(area).add(notification);
fade.play();
final Timeline timeline = new Timeline(new KeyFrame(
TIMER, ev -> ref.get().fadeAway()
));
timeline.play();
});
}
private static void remove(Node node) {
siblingsOf(node).remove(node);
}
private static ObservableList<Node> siblingsOf(Node node) {
final Parent parent = node.getParent();
if (parent == null) {
throw new NullPointerException(
"Can't delete node from 'null' parent."
);
}
return childrenOf(parent);
}
private static ObservableList<Node> childrenOf(Node parent) {<FILL_FUNCTION_BODY>}
}
|
final Method getChildren;
try {
getChildren = parent.getClass().getMethod("getChildren");
} catch (final NoSuchMethodException | SecurityException ex) {
throw new SpeedmentToolException(
"Could not find public method 'getChildren()' in class '" +
parent.getClass() + "'.", ex
);
}
try {
@SuppressWarnings("unchecked")
final ObservableList<Node> siblings = (ObservableList<Node>) getChildren.invoke(parent);
return siblings;
} catch (final IllegalAccessException
| IllegalArgumentException
| InvocationTargetException
| ClassCastException ex) {
throw new SpeedmentToolException(
"Error executing 'getChildren()' in class '" +
parent.getClass() + "'.", ex
);
}
| 1,090
| 213
| 1,303
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-core/src/main/java/com/speedment/tool/core/internal/controller/OutputController.java
|
OutputController
|
initialize
|
class OutputController implements Initializable {
public @Inject UserInterfaceComponent ui;
private @FXML VBox log;
private @FXML ScrollPane logPane;
private @FXML ToggleButton wrapTextBtn;
private @FXML ToggleButton scrollToEndBtn;
private @FXML Button clearLogBtn;
@Override
public void initialize(URL location, ResourceBundle resources) {<FILL_FUNCTION_BODY>}
private void styleToolbarButton(ButtonBase btn, Node icon) {
btn.setGraphic(icon);
btn.setContentDisplay(ContentDisplay.GRAPHIC_ONLY);
}
private void scrollLogToEnd() {
logPane.setVvalue(1.0);
}
}
|
Bindings.bindContent(
log.getChildren(),
ui.outputMessages()
);
log.heightProperty().addListener(e -> {
if (scrollToEndBtn.isSelected()) {
scrollLogToEnd();
}
});
logPane.fitToWidthProperty().bind(wrapTextBtn.selectedProperty());
scrollToEndBtn.setSelected(true);
scrollToEndBtn.setOnAction(e -> {
if (scrollToEndBtn.isSelected()) {
scrollLogToEnd();
}
});
clearLogBtn.setOnAction(ev -> ui.outputMessages().clear());
clearLogBtn.disableProperty().bind(Bindings.isEmpty(log.getChildren()));
styleToolbarButton(wrapTextBtn, MaterialIcon.WRAP_TEXT.view());
styleToolbarButton(clearLogBtn, FontAwesome.TRASH.view());
styleToolbarButton(scrollToEndBtn, MaterialIcon.SCROLL_TEXT.view());
| 193
| 262
| 455
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-core/src/main/java/com/speedment/tool/core/internal/controller/ProjectTreeController.java
|
DocumentPropertyCell
|
updateEnabled
|
class DocumentPropertyCell extends TreeCell<DocumentProperty> {
private final ChangeListener<Boolean> change = (ob, o, enabled) -> {
if (enabled) {
enable();
} else {
disable();
}
};
private final ProjectTreeComponent projectTreeComponent;
DocumentPropertyCell(ProjectTreeComponent projectTreeComponent) {
this.projectTreeComponent = requireNonNull(projectTreeComponent);
// Listener should be initiated with a listener attached
// that removes enabled-listeners attached to the previous
// node when a new node is selected.
itemProperty().addListener((ob, o, n) -> {
if (o instanceof HasEnabledProperty) {
final HasEnabledProperty hasEnabled = (HasEnabledProperty) o;
hasEnabled.enabledProperty().removeListener(change);
}
if (n instanceof HasEnabledProperty) {
final HasEnabledProperty hasEnabled = (HasEnabledProperty) n;
hasEnabled.enabledProperty().addListener(change);
}
});
}
private void disable() {
getStyleClass().add("gui-disabled");
}
private void enable() {
while (getStyleClass().remove("gui-disabled")) {
// Do nothing.
}
}
@Override
protected void updateItem(DocumentProperty item, boolean empty) {
// item can be null
super.updateItem(item, empty);
if (empty || item == null) {
textProperty().unbind();
setText(null);
setGraphic(null);
setContextMenu(null);
disable();
} else {
final ImageView icon;
if (item instanceof HasIconPath) {
final HasIconPath hasIcon = (HasIconPath) item;
icon = new ImageView(new Image(hasIcon.getIconPath()));
} else {
icon = SpeedmentIcon.forNode(item);
}
setGraphic(icon);
if (item instanceof HasNameProperty) {
@SuppressWarnings("unchecked")
final HasNameProperty withName = (HasNameProperty) item;
textProperty().bind(withName.nameProperty());
} else {
textProperty().unbind();
textProperty().setValue(null);
}
projectTreeComponent.createContextMenu(this, item)
.ifPresent(this::setContextMenu);
updateEnabled(item);
getTreeView().refresh();
}
}
private void updateEnabled(DocumentProperty item) {<FILL_FUNCTION_BODY>}
}
|
boolean indicateEnabled = HasEnabled.test(item);
if (item instanceof ColumnProperty) {
indicateEnabled &= ((ColumnProperty) item).getParentOrThrow().isEnabled();
} else if (item instanceof IndexProperty) {
indicateEnabled &= ((IndexProperty) item).getParentOrThrow().isEnabled();
} else if (item instanceof PrimaryKeyColumnProperty) {
indicateEnabled &= ((PrimaryKeyColumnProperty) item).getParentOrThrow().isEnabled();
}
if (indicateEnabled) {
enable();
} else {
disable();
}
| 644
| 144
| 788
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-core/src/main/java/com/speedment/tool/core/internal/controller/SceneController.java
|
SceneController
|
initialize
|
class SceneController implements Initializable {
private static final Logger LOGGER = LoggerManager.getLogger(SceneController.class);
private static final SemanticVersionComparator SEMANTIC_VERSION =
new SemanticVersionComparator();
public @Inject UserInterfaceComponent ui;
public @Inject InfoComponent info;
public @Inject InjectionLoader loader;
public @Inject VersionComponent version;
public @Inject ProjectComponent projects;
private @FXML VBox top;
private @FXML SplitPane horizontal;
private @FXML SplitPane vertical;
@Override
public void initialize(URL location, ResourceBundle resources) {<FILL_FUNCTION_BODY>}
}
|
top.getChildren().add(loader.load("Menubar"));
top.getChildren().add(loader.load("Toolbar"));
final Node projectTree = loader.load("ProjectTree");
final Node workspace = loader.load("Workspace");
final Node output = loader.load("Output");
horizontal.getItems().add(0, projectTree);
vertical.getItems().add(workspace);
vertical.getItems().add(output);
ui.prepareProjectTree(horizontal, projectTree);
ui.prepareWorkspace(vertical, workspace);
ui.prepareOutput(vertical, output);
horizontal.setDividerPositions(0.3, 0.7);
vertical.setDividerPositions(0.7, 0.3);
Statistics.report(info, projects, GUI_PROJECT_LOADED);
CompletableFuture.runAsync(() -> {
try {
version.latestVersion()
.thenAcceptAsync(release -> runLater(() -> {
final int compare = SEMANTIC_VERSION.compare(
release, info.getImplementationVersion()
);
if (compare == 0) {
ui.showNotification(
"Your version of " + info.getTitle() + " is up to date."
);
} else if (compare > 0) {
ui.showNotification(
"A new version " + release +
" of " + info.getTitle() + " is available."
);
} else {
ui.showNotification(
"Your version " + info.getImplementationVersion() +
" of " + info.getTitle() + " is newer than the released " +
release + "."
);
}
})).get(3, TimeUnit.SECONDS);
} catch (final ExecutionException ex) {
LOGGER.debug(ex, "Error loading last released version.");
} catch (final InterruptedException ex) {
LOGGER.debug(ex, "Error loading last released version.");
Thread.currentThread().interrupt();
} catch (final TimeoutException ex) {
LOGGER.debug(ex, "Request for latest released version timed out.");
}
});
| 183
| 546
| 729
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-core/src/main/java/com/speedment/tool/core/internal/controller/WorkspaceController.java
|
WorkspaceController
|
initialize
|
class WorkspaceController implements Initializable {
private final ObservableList<PropertyEditor.Item> properties;
@Inject public UserInterfaceComponent ui;
@Inject public EventComponent events;
@Inject public PropertyEditorComponent editors;
@FXML private TitledPane workspace;
@FXML private ScrollPane scrollpane;
public WorkspaceController() {
this.properties = FXCollections.observableArrayList();
}
@Override
public void initialize(URL location, ResourceBundle resources) {<FILL_FUNCTION_BODY>}
private ListChangeListener<TreeItem<DocumentProperty>> treeItemListChangeListener() {
return change -> {
properties.clear();
if (!change.getList().isEmpty()) {
final TreeItem<DocumentProperty> treeItem = change.getList().get(0);
if (treeItem != null) {
final DocumentProperty property = treeItem.getValue();
final HasNameProperty withName = (HasNameProperty) property;
final String extraInfo = Cast.cast(property, ColumnProperty.class)
.map(ColumnProperty::findDatabaseType)
.map(Class::getSimpleName)
.map(s -> "(" + s + ")")
.orElse("");
workspace.textProperty().bind(
Bindings.createStringBinding(() -> String.format(
"Settings for database %s '%s' %s",
type(withName),
withName.getName(),
extraInfo
), withName.nameProperty())
);
editors.getUiVisibleProperties(treeItem.getValue())
.forEachOrdered(properties::add);
}
}
@SuppressWarnings("unchecked")
final ListChangeListener.Change<TreeItem<DocumentProperty>> changeCasted = (ListChangeListener.Change<TreeItem<DocumentProperty>>) change;
events.notify(new TreeSelectionChange(changeCasted, properties));
};
}
private String type(HasNameProperty withName) {
if (withName instanceof Table) {
return ((Table) withName).isView() ? "view" : "table";
} else {
return withName.mainInterface().getSimpleName().toLowerCase();
}
}
}
|
final PropertySheet sheet = new PropertySheet(properties);
ui.getSelectedTreeItems().addListener(treeItemListChangeListener());
scrollpane.setContent(sheet);
Bindings.bindContentBidirectional(ui.getProperties(), properties);
| 563
| 67
| 630
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-core/src/main/java/com/speedment/tool/core/internal/menubar/DefaultMenuItemFactories.java
|
DefaultMenuItemFactories
|
install
|
class DefaultMenuItemFactories {
@ExecuteBefore(State.INITIALIZED)
public void install(@WithState(State.INITIALIZED) MenuBarComponent menuBar,
@WithState(State.INITIALIZED) UserInterfaceComponent ui,
@WithState(State.INITIALIZED) InjectionLoader loader) {<FILL_FUNCTION_BODY>}
}
|
menuBar.forTab(MenuBarTab.FILE)
.addMenuItem("_New", SpeedmentIcon.NEW_PROJECT, ev -> ui.newProject())
.addMenuItem("_Open", SpeedmentIcon.OPEN_PROJECT, ev -> ui.openProject())
.addSeparator()
.addMenuItem("_Save", SpeedmentIcon.DISK, ev -> ui.saveProject())
.addMenuItem("Save _As", SpeedmentIcon.DISK_MULTIPLE, ev -> ui.saveProjectAs())
.addSeparator()
.addMenuItem("_Quit", SpeedmentIcon.DOOR_IN, ev -> ui.quit());
menuBar.forTab(MenuBarTab.EDIT)
.addMenuItem("_Generate", SpeedmentIcon.RUN_PROJECT, ev -> ui.generate());
menuBar.forTab(MenuBarTab.WINDOW)
.set("project-tree", () -> {
final CheckMenuItem mi = new CheckMenuItem("_Project Tree");
mi.setGraphic(SpeedmentIcon.APPLICATION_SIDE_TREE.view());
mi.selectedProperty().bindBidirectional(ui.projectTreeVisibleProperty());
return mi;
})
.set("workspace", () -> {
final CheckMenuItem mi = new CheckMenuItem("_Workspace");
mi.setGraphic(SpeedmentIcon.APPLICATION_FORM.view());
mi.selectedProperty().bindBidirectional(ui.workspaceVisibleProperty());
return mi;
})
.set("output", () -> {
final CheckMenuItem mi = new CheckMenuItem("_Output");
mi.setGraphic(SpeedmentIcon.APPLICATION_XP_TERMINAL.view());
mi.selectedProperty().bindBidirectional(ui.outputVisibleProperty());
return mi;
});
menuBar.forTab(MenuBarTab.HELP)
.addMenuItem("Online _Manual", SpeedmentIcon.BOOK, ev -> ui.showManual())
.addMenuItem("Online Help Chat on _Gitter", SpeedmentIcon.USER_COMMENT, ev -> ui.showGitter())
.addMenuItem("Report an _Issue", SpeedmentIcon.USER_COMMENT, ev -> ui.reportIssue())
.addMenuItem("Open the Git_Hub page", SpeedmentIcon.USER_COMMENT, ev -> ui.showGithub())
.addSeparator()
.addMenuItem("_Components", SpeedmentIcon.BRICKS, ev -> loader.loadAsModal("Components"))
.addSeparator()
.addMenuItem("_About", SpeedmentIcon.INFORMATION, ev -> loader.loadAsModal("About"));
| 99
| 679
| 778
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-core/src/main/java/com/speedment/tool/core/internal/menubar/MenuBarTabHandlerImpl.java
|
MenuBarTabHandlerImpl
|
set
|
class MenuBarTabHandlerImpl implements MenuBarTabHandler {
private final Map<String, MenuItemFactory> byKey;
private final List<MenuItemFactory> factories;
private final Injector injector;
MenuBarTabHandlerImpl(Injector injector) {
this.injector = requireNonNull(injector);
this.byKey = new HashMap<>();
this.factories = new ArrayList<>();
}
@Override
public MenuBarTabHandler add(MenuItemFactory factory) {
factories.add(injector.inject(factory));
return this;
}
@Override
public MenuBarTabHandler set(String key, MenuItemFactory factory) {<FILL_FUNCTION_BODY>}
@Override
public MenuBarTabHandler insert(int index, MenuItemFactory factory) {
factories.add(index, injector.inject(factory));
return this;
}
@Override
public boolean remove(String key) {
final MenuItemFactory oldFactory = byKey.remove(key);
if (oldFactory == null) {
return false;
} else {
factories.remove(oldFactory);
return true;
}
}
@Override
public int indexOf(String key) {
final MenuItemFactory factory = byKey.get(key);
if (factory == null) return -1;
else return factories.indexOf(factory);
}
@Override
public void populate(Menu menu) {
final ObservableList<MenuItem> items = menu.getItems();
items.clear();
for (final MenuItemFactory factory : factories) {
items.add(factory.createMenuItem());
}
}
}
|
injector.inject(factory);
final MenuItemFactory oldFactory = byKey.put(key, factory);
if (oldFactory == null) {
factories.add(factory);
} else {
factories.set(factories.indexOf(oldFactory), factory);
}
return this;
| 440
| 80
| 520
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-core/src/main/java/com/speedment/tool/core/internal/toolbar/BrandToolbarItem.java
|
BrandToolbarItem
|
createNode
|
class BrandToolbarItem implements ToolbarItem<ImageView> {
private final Brand brand;
public BrandToolbarItem(Brand brand) {
this.brand = requireNonNull(brand);
}
@Override
public ImageView createNode() {<FILL_FUNCTION_BODY>}
@Override
public ToolbarSide getSide() {
return ToolbarSide.RIGHT;
}
}
|
final ImageView view = new ImageView();
view.setPreserveRatio(true);
view.setFitHeight(48);
brand.logoLarge()
.map(Image::new)
.ifPresent(view::setImage);
return view;
| 108
| 70
| 178
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-core/src/main/java/com/speedment/tool/core/internal/toolbar/ToolbarComponentImpl.java
|
ToolbarComponentImpl
|
populate
|
class ToolbarComponentImpl implements ToolbarComponent {
private final Map<String, ToolbarItem<?>> byKey;
private final List<ToolbarItem<?>> leftSide;
private final List<ToolbarItem<?>> rightSide;
private Injector injector;
public ToolbarComponentImpl() {
this.byKey = new HashMap<>();
this.leftSide = new ArrayList<>();
this.rightSide = new ArrayList<>();
}
@ExecuteBefore(INITIALIZED)
public void setInjector(Injector injector) {
this.injector = requireNonNull(injector);
}
@Override
public void install(ToolbarItem<Button> item) {
install(injector.inject(item).createNode().getText(), item);
}
@Override
public <T extends Node> void install(String key, ToolbarItem<T> item) {
injector.inject(item);
final ToolbarItem<?> oldItem = byKey.put(key, item);
if (oldItem == null) {
switch (item.getSide()) {
case LEFT: leftSide.add(item); break;
case RIGHT: rightSide.add(item); break;
default: throw new UnsupportedOperationException(format(
"Unknown enum constant '%s'.", item.getSide()));
}
} else {
switch (oldItem.getSide()) {
case LEFT: leftSide.set(leftSide.indexOf(oldItem), item); break;
case RIGHT: rightSide.set(rightSide.indexOf(oldItem), item); break;
default: throw new UnsupportedOperationException(format(
"Unknown enum constant '%s'.", item.getSide()));
}
}
}
@Override
public void populate(Pane parent) {<FILL_FUNCTION_BODY>}
}
|
final ObservableList<Node> children = parent.getChildren();
children.clear();
leftSide.stream()
.map(ToolbarItem::createNode)
.forEachOrdered(children::add);
final Pane separator = new Pane();
separator.setPrefHeight(1);
HBox.setHgrow(separator, Priority.ALWAYS);
children.add(separator);
final ListIterator<ToolbarItem<?>> it = rightSide.listIterator(rightSide.size());
while (it.hasPrevious()) {
children.add(it.previous().createNode());
}
| 478
| 161
| 639
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-core/src/main/java/com/speedment/tool/core/internal/util/InjectionLoaderImpl.java
|
InjectionLoaderImpl
|
loadAsModal
|
class InjectionLoaderImpl implements InjectionLoader {
private static final String FXML_PREFIX = "/fxml/";
private static final String FXML_SUFFIX = ".fxml";
private final Map<Class<?>, Supplier<? extends Initializable>> constructors;
private final InfoComponent infoComponent;
private final Brand brand;
private UserInterfaceComponent userInterfaceComponent;
private Injector injector;
public InjectionLoaderImpl(
final InfoComponent infoComponent,
final Brand brand
) {
this.infoComponent = requireNonNull(infoComponent);
this.brand = requireNonNull(brand);
constructors = new ConcurrentHashMap<>();
}
@ExecuteBefore(value = INITIALIZED, missingArgument = MissingArgumentStrategy.SKIP_INVOCATION)
public void setUserInterfaceComponent(UserInterfaceComponent userInterfaceComponent) {
this.userInterfaceComponent = requireNonNull(userInterfaceComponent);
}
@ExecuteBefore(INITIALIZED)
public void setInjector(Injector injector) {
this.injector = requireNonNull(injector);
}
@ExecuteBefore(INITIALIZED)
public void installConstructors() {
constructors.put(AboutController.class, AboutController::new);
constructors.put(ComponentsController.class, ComponentsController::new);
constructors.put(ConnectController.class, ConnectController::new);
constructors.put(MailPromptController.class, MailPromptController::new);
constructors.put(MenubarController.class, MenubarController::new);
constructors.put(NotificationAreaController.class, NotificationAreaController::new);
constructors.put(OutputController.class, OutputController::new);
constructors.put(ProjectTreeController.class, ProjectTreeController::new);
constructors.put(SceneController.class, SceneController::new);
constructors.put(ToolbarController.class, ToolbarController::new);
constructors.put(WorkspaceController.class, WorkspaceController::new);
constructors.put(ProjectProblemController.class, ProjectProblemController::new);
}
public FXMLLoader fxmlLoader() {
final FXMLLoader loader = new FXMLLoader(StandardCharsets.UTF_8);
loader.setControllerFactory(clazz -> MapStream.of(constructors)
.filterKey(clazz::isAssignableFrom)
.values()
.findFirst()
.map(Supplier::get)
.map(injector::inject)
.orElseThrow(() -> new SpeedmentToolException(
"FXML Controller '" + clazz.getName() +
"' have not been installed in " +
getClass().getSimpleName() + "."
)));
return loader;
}
@Override
public <T extends Initializable> void install(Class<T> controllerClass, Supplier<T> newController) {
constructors.put(controllerClass, newController);
}
@Override
public Node load(String name) {
final FXMLLoader loader = fxmlLoader();
final String filename = FXML_PREFIX + name + FXML_SUFFIX;
loader.setLocation(InjectionLoaderImpl.class.getResource(filename));
try {
return loader.load();
} catch (final IOException ex) {
throw new SpeedmentToolException(
"Error! Could not find FXML-file: " + filename + ".", ex
);
}
}
@Override
public Parent loadAndShow(String name) {
final Parent parent = (Parent) load(name);
final Stage stage = requireNonNull(userInterfaceComponent.getStage());
final Scene scene = new Scene(parent);
stage.hide();
BrandUtil.applyBrand(injector, stage, scene);
stage.setScene(scene);
WindowSettingUtil.applySaveOnCloseMethod(stage, name);
if ("Scene".equals(name)) {
WindowSettingUtil.applyStoredDisplaySettings(stage, name);
}
stage.show();
return parent;
}
@Override
public Parent loadAsModal(String name) {<FILL_FUNCTION_BODY>}
}
|
final Stage mainStage = requireNonNull(userInterfaceComponent.getStage());
final Stage dialog = new Stage();
final Parent root = (Parent) load(name);
final Scene scene = new Scene(root);
BrandUtil.applyBrandToScene(injector, scene);
dialog.setTitle("About " + infoComponent.getTitle());
dialog.initModality(APPLICATION_MODAL);
brand.logoSmall().map(Image::new).ifPresent(dialog.getIcons()::add);
dialog.initOwner(mainStage);
dialog.setScene(scene);
dialog.show();
return root;
| 1,104
| 173
| 1,277
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-core/src/main/java/com/speedment/tool/core/internal/util/SemanticVersionComparator.java
|
SemanticVersionComparator
|
compare
|
class SemanticVersionComparator implements Comparator<String> {
private static final Pattern NUMERIC =
Pattern.compile("^[0-9]+$");
@Override
public int compare(String first, String second) {<FILL_FUNCTION_BODY>}
private OptionalInt compareWords(String firstWord, String secondWord) {
// If they are completely equal, continue to the next word.
if (firstWord.equals(secondWord)) {
return OptionalInt.empty();
}
// Snapshots are considered < than everything.
if ("SNAPSHOT".equals(firstWord)) {
return OptionalInt.of(-1);
} else if ("SNAPSHOT".equals(secondWord)) {
return OptionalInt.of(1);
}
// Releases are considered > than everything.
if ("RELEASE".equals(firstWord)) {
return OptionalInt.of(1);
} else if ("RELEASE".equals(secondWord)) {
return OptionalInt.of(-1);
}
// Since neither is a release, an early access is > than everything else.
if ("EA".equals(firstWord)) {
return OptionalInt.of(1);
} else if ("EA".equals(secondWord)) {
return OptionalInt.of(-1);
}
final OptionalInt c = compareNonNumericChars(firstWord, secondWord);
return c.isPresent() ? c : OptionalInt.empty();
}
private OptionalInt compareNonNumericChars(String firstWord, String secondWord) {
// Look for any initial non-numeric characters. If present, we
// should begin by comparing those.
final Matcher fn = NUMERIC.matcher(firstWord);
final Matcher sn = NUMERIC.matcher(secondWord);
if (fn.find()) {
if (sn.find()) { // Both are numeric
final int f = Integer.parseInt(fn.group());
final int s = Integer.parseInt(sn.group());
final int c = Integer.compare(f, s);
if (c != 0) return OptionalInt.of(c);
} else { // secondWord is not numeric. We are not equal.
return OptionalInt.of(firstWord.compareTo(secondWord));
}
} else {
if (sn.find()) { // secondWord is numeric but firstWord isn't
return OptionalInt.of(firstWord.compareTo(secondWord));
} else { // Neither is numeric
final int c = firstWord.compareTo(secondWord);
if (c != 0) return OptionalInt.of(c);
}
}
return OptionalInt.empty();
}
}
|
if (first == null || second == null) {
return first == null ? 1 : -1;
} else {
final String[] firstWords = first.split("(\\.|-)");
final String[] secondWords = second.split("(\\.|-)");
for (int i = 0; i < Math.min(firstWords.length, secondWords.length); i++) {
final OptionalInt j = compareWords(firstWords[i], secondWords[i]);
if (j.isPresent()) return j.getAsInt();
}
// If first has more words, it is considered greater
// (1.0 > 1.0-SNAPSHOT)
if (firstWords.length < secondWords.length) {
return 1;
} else if (firstWords.length > secondWords.length) {
return -1;
} else {
return 0;
}
}
| 684
| 241
| 925
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-core/src/main/java/com/speedment/tool/core/internal/util/Throttler.java
|
Throttler
|
call
|
class Throttler {
/**
* Returns a {@link Throttler} that never executes the same request more
* than once every {@code millis}.
*
* @param millis minimum frequency in milliseconds
* @return the created throttler
*/
public static Throttler limitToOnceEvery(long millis) {
return new Throttler(millis);
}
private final ConcurrentHashMap<String, AtomicLong> timers;
private final long millis;
private Throttler(long millis) {
this.millis = millis;
this.timers = new ConcurrentHashMap<>();
}
/**
* Attempts to invoke the specified {@code runnable} if no other action with
* the same specifier has been called recently. Otherwise, the method will
* return with no effect.
*
* @param action the action specifier
* @param runnable the callable action to invoke
*/
public void call(String action, Runnable runnable) {<FILL_FUNCTION_BODY>}
private static long now() {
return System.currentTimeMillis();
}
}
|
final long now = now();
final AtomicLong timer = timers.computeIfAbsent(action, a -> new AtomicLong(0));
if (now == timer.updateAndGet(
lastCall -> lastCall + millis < now
? now : lastCall
)) runnable.run();
| 309
| 81
| 390
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-core/src/main/java/com/speedment/tool/core/internal/util/WindowSettingUtil.java
|
WindowSettingUtil
|
applyStoredDisplaySettings
|
class WindowSettingUtil {
private static final Logger LOGGER = LoggerManager.getLogger(WindowSettingUtil.class);
private static final Preferences PREFERENCES = Preferences.userNodeForPackage(WindowSettingUtil.class);
private static final String WINDOW_WIDTH = "windowWidth";
private static final String WINDOW_HEIGHT = "windowHeight";
private static final String WINDOW_X_POS = "windowXPos";
private static final String WINDOW_Y_POS = "windowYPos";
private static final String WINDOW_MAXIMIZED = "windowMaximized";
private static final double DEFUALT_WIDTH = 1280;
private static final double DEFUALT_HEIHGT = 720;
private static final double DEFUALT_X = 0;
private static final double DEFUALT_Y = 0;
private WindowSettingUtil() {}
/**
* Retrieves data about he window settings from the previous session and applies
* them to the stage. These settings include window size, position and if
* it was maximized or not.
*
* @param stage the stage to apply these settings to
* @param name the name under which we stored the settings
*/
static void applyStoredDisplaySettings(Stage stage, String name){<FILL_FUNCTION_BODY>}
/**
* Adds an OnCloseRequest handle to the window which will store the position,
* size and maximized status of the window.
*
* @param stage the stage to read settings from
* @param name the name under which we store the settings
*/
static void applySaveOnCloseMethod(Stage stage, String name){
stage.setOnCloseRequest( ev -> {
try {
Preferences stagePreferences = PREFERENCES.node(name);
if( stage.isMaximized() ){
stagePreferences.putBoolean(WINDOW_MAXIMIZED, true);
} else {
stagePreferences.putBoolean(WINDOW_MAXIMIZED, false);
stagePreferences.putDouble(WINDOW_X_POS, stage.getX());
stagePreferences.putDouble(WINDOW_Y_POS, stage.getY());
stagePreferences.putDouble(WINDOW_WIDTH, stage.getWidth());
stagePreferences.putDouble(WINDOW_HEIGHT, stage.getHeight());
}
stagePreferences.flush();
} catch (final BackingStoreException ex) {
LOGGER.error(ex, "Could not flush preferences for window " + name);
}
});
}
}
|
try {
if( PREFERENCES.nodeExists(name) ){
Preferences stagePreferences = PREFERENCES.node(name);
boolean wasMaximized = stagePreferences.getBoolean(WINDOW_MAXIMIZED, false);
if( wasMaximized ){
stage.setMaximized(true);
} else {
stage.setX( stagePreferences.getDouble(WINDOW_X_POS, DEFUALT_X));
stage.setY( stagePreferences.getDouble(WINDOW_Y_POS, DEFUALT_Y));
stage.setWidth( stagePreferences.getDouble(WINDOW_WIDTH, DEFUALT_WIDTH));
stage.setHeight(stagePreferences.getDouble(WINDOW_HEIGHT, DEFUALT_HEIHGT));
}
}
} catch (BackingStoreException ex) {
LOGGER.error(ex, "Could not access preferences for window " + name);
}
| 673
| 258
| 931
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-core/src/main/java/com/speedment/tool/core/util/BrandUtil.java
|
BrandUtil
|
applyBrandToScene
|
class BrandUtil {
private BrandUtil() {}
public static void applyBrand(Injector injector, Stage stage) {
applyBrand(injector, stage, stage.getScene());
}
public static void applyBrand(Injector injector, Stage stage, Scene scene) {
applyBrandToStage(injector, stage);
final Brand brand = injector.getOrThrow(Brand.class);
final InfoComponent info = injector.getOrThrow(InfoComponent.class);
apply(brand, info, stage, scene);
}
public static void applyBrandToStage(Injector injector, Stage stage) {
final InfoComponent info = injector.getOrThrow(InfoComponent.class);
final Brand brand = injector.getOrThrow(Brand.class);
stage.setTitle(info.getTitle());
brand.logoSmall()
.map(Image::new)
.ifPresent(stage.getIcons()::add);
}
public static void applyBrandToScene(Injector injector, Scene scene) {<FILL_FUNCTION_BODY>}
private static void apply(Brand brand, InfoComponent info, Stage stage, Scene scene) {
if (stage != null) {
stage.setTitle(info.getTitle());
}
brand.logoSmall()
.map(Image::new)
.ifPresent(icon -> {
if (stage != null) {
stage.getIcons().add(icon);
}
@SuppressWarnings("unchecked")
final Stage dialogStage = (Stage) scene.getWindow();
if (dialogStage != null) {
dialogStage.getIcons().add(icon);
}
});
brand.stylesheets().forEachOrdered(scene.getStylesheets()::add);
}
}
|
final Brand brand = injector.getOrThrow(Brand.class);
final UserInterfaceComponent ui = injector.getOrThrow(UserInterfaceComponent.class);
final InfoComponent info = injector.getOrThrow(InfoComponent.class);
final Stage stage = scene.getWindow() == null
? ui.getStage()
: (Stage) scene.getWindow();
apply(brand, info, stage, scene);
| 491
| 115
| 606
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-propertyeditor/src/main/java/com/speedment/tool/propertyeditor/editor/CompanyNamePropertyEditor.java
|
CompanyNamePropertyEditor
|
fieldsFor
|
class CompanyNamePropertyEditor <T extends ProjectProperty> implements PropertyEditor<T>{
@Override
public Stream<Item> fieldsFor(T document) {<FILL_FUNCTION_BODY>}
}
|
return Stream.of(new SimpleTextFieldItem(
"Company Name",
document.companyNameProperty(),
"The company name that should be used for this project. It is used in the generated code."
)
);
| 54
| 58
| 112
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-propertyeditor/src/main/java/com/speedment/tool/propertyeditor/editor/ConnectionUrlPropertyEditor.java
|
ConnectionUrlPropertyEditor
|
defaultConnectionUrlProperty
|
class ConnectionUrlPropertyEditor<T extends DbmsProperty> implements PropertyEditor<T> {
public @Inject Injector injector;
@Override
public Stream<Item> fieldsFor(T document) {
final DbmsHandlerComponent dbmsHandler = injector.getOrThrow(DbmsHandlerComponent.class);
return Stream.of(
new DefaultTextAreaItem(
"Connection URL",
defaultConnectionUrlProperty(document, dbmsHandler),
document.connectionUrlProperty(),
"The connection URL that should be used when establishing " +
"connection with the database. If this is set to Auto, the " +
"DbmsType will generate one."
)
);
}
protected StringBinding defaultConnectionUrlProperty(T document, DbmsHandlerComponent dbmsHandlerComponent) {<FILL_FUNCTION_BODY>}
}
|
return Bindings.createStringBinding(() ->
DatabaseUtil.findDbmsType(dbmsHandlerComponent, document).getConnectionUrlGenerator().from(document),
document.typeNameProperty(),
document.ipAddressProperty(),
document.portProperty(),
document.usernameProperty()
);
| 218
| 76
| 294
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-propertyeditor/src/main/java/com/speedment/tool/propertyeditor/editor/DbmsTypePropertyEditor.java
|
DbmsTypePropertyEditor
|
fieldsFor
|
class DbmsTypePropertyEditor<T extends DbmsProperty> implements PropertyEditor<T> {
public @Inject DbmsHandlerComponent dbmsHandler;
@Override
public Stream<Item> fieldsFor(T document) {<FILL_FUNCTION_BODY>}
}
|
final ObservableList<String> supportedTypes = observableList(
dbmsHandler
.supportedDbmsTypes()
.map(DbmsType::getName)
.collect(toList())
);
return Stream.of(new ChoiceBoxItem<String>(
"Dbms Type",
document.typeNameProperty(),
supportedTypes,
"Which type of database this is. If the type you are looking " +
"for is missing, make sure it has been loaded properly in " +
"the pom.xml-file."
)
);
| 73
| 144
| 217
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-propertyeditor/src/main/java/com/speedment/tool/propertyeditor/editor/ImplementsEditor.java
|
ImplementsEditor
|
fieldsFor
|
class ImplementsEditor<T extends TableProperty> implements PropertyEditor<T> {
private static final String TOOLTIP =
"A comma-separated list of interfaces that this table will implement upon generation.\n"
+ "\n"
+ "Example: com.company.custom.MyInterface, com.company.custom.AnotherInterface";
@Override
public Stream<Item> fieldsFor(T document) {<FILL_FUNCTION_BODY>}
}
|
return Stream.of(
new SimpleTextFieldItem(
"Implements",
document.stringPropertyOf(TableUtil.IMPLEMENTS, () -> ""),
TOOLTIP
)
);
| 114
| 56
| 170
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-propertyeditor/src/main/java/com/speedment/tool/propertyeditor/editor/IpAdressPropertyEditor.java
|
IpAdressPropertyEditor
|
fieldsFor
|
class IpAdressPropertyEditor<T extends DbmsProperty> implements PropertyEditor<T> {
@Override
public Stream<Item> fieldsFor(T document) {<FILL_FUNCTION_BODY>}
}
|
return Stream.of(new DefaultTextFieldItem(
"IP Adress",
new SimpleStringProperty("127.0.0.1"),
document.ipAddressProperty(),
"The IP Address of the database host."
));
| 56
| 66
| 122
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-propertyeditor/src/main/java/com/speedment/tool/propertyeditor/editor/NamePropertyEditor.java
|
NamePropertyEditor
|
fieldsFor
|
class NamePropertyEditor<T extends HasNameProperty> implements PropertyEditor<T>{
@Override
public Stream<PropertyEditor.Item> fieldsFor(T document) {<FILL_FUNCTION_BODY>}
}
|
return Stream.of(new SimpleTextFieldItem(
document.mainInterface().getSimpleName() + " Name",
document.nameProperty(),
"The name of the persisted entity in the database. This should only be modified if the database has been changed!",
editor -> document instanceof HasNameProtectedProperty ?
lockDecorator(editor, document,
"This field should ONLY be changed to reflect changes made in the underlying database. "
+ "If you want to change the name of this entity in Java, consider editing the Alias field instead."
+ "\nEnable editing by by right clicking on the field."
) : editor
));
| 55
| 159
| 214
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-propertyeditor/src/main/java/com/speedment/tool/propertyeditor/editor/OrderTypePropertyEditor.java
|
OrderTypePropertyEditor
|
fieldsFor
|
class OrderTypePropertyEditor<T extends HasOrderTypeProperty> implements PropertyEditor<T>{
@Override
public Stream<Item> fieldsFor(T document) {<FILL_FUNCTION_BODY>}
}
|
final ObservableList<OrderType> alternatives =
FXCollections.observableArrayList(OrderType.values());
return Stream.of(
new ChoiceBoxItem<>(
"Order Type",
document.orderTypeProperty(),
alternatives,
"The order in which elements will be considered.",
editor -> ItemUtil.lockDecorator(editor, document, ItemUtil.DATABASE_RELATION_TOOLTIP)
)
);
| 57
| 119
| 176
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-propertyeditor/src/main/java/com/speedment/tool/propertyeditor/editor/PackageLocationPropertyEditor.java
|
PackageLocationPropertyEditor
|
fieldsFor
|
class PackageLocationPropertyEditor<T extends ProjectProperty> implements PropertyEditor<T> {
@Override
public Stream<Item> fieldsFor(T document) {<FILL_FUNCTION_BODY>}
}
|
return Stream.of(
new DefaultTextFieldItem(
"Package Location",
new SimpleStringProperty(DEFAULT_PACKAGE_LOCATION),
document.packageLocationProperty(),
"The folder to store all generated files in. This should be a relative name from the working directory."
)
);
| 54
| 77
| 131
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-propertyeditor/src/main/java/com/speedment/tool/propertyeditor/editor/PackageNameEditor.java
|
PackageNameEditor
|
fieldsFor
|
class PackageNameEditor<T extends HasPackageNameProperty> implements PropertyEditor<T>{
public @Inject Injector injector;
@Override
public Stream<Item> fieldsFor(T document) {<FILL_FUNCTION_BODY>}
}
|
return Stream.of(
new DefaultTextFieldItem(
"Package Name",
document.defaultPackageNameProperty(injector),
document.packageNameProperty(),
"The package where generated classes will be located."
)
);
| 68
| 64
| 132
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-propertyeditor/src/main/java/com/speedment/tool/propertyeditor/editor/PortNumberEditor.java
|
PortNumberEditor
|
fieldsFor
|
class PortNumberEditor<T extends DbmsProperty> implements PropertyEditor<T> {
public @Inject DbmsHandlerComponent dbmsHandler;
@Override
public Stream<Item> fieldsFor(T document) {<FILL_FUNCTION_BODY>}
private IntegerBinding defaultPortProperty(T document, DbmsHandlerComponent dbmsHandlerComponent) {
return Bindings.createIntegerBinding(() ->
DatabaseUtil.findDbmsType(dbmsHandlerComponent, document).getDefaultPort(),
document.typeNameProperty()
);
}
}
|
return Stream.of(new DefaultSpinnerItem(
"Port",
defaultPortProperty(document, dbmsHandler),
document.portProperty(),
"The port of the database on the database host.",
0, 65535
));
| 143
| 72
| 215
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-propertyeditor/src/main/java/com/speedment/tool/propertyeditor/editor/TypeMapperPropertyEditor.java
|
TypeMapperPropertyEditor
|
fieldsFor
|
class TypeMapperPropertyEditor<T extends HasTypeMapperProperty> implements PropertyEditor<T> {
private static final String IDENTITY_MAPPER = "(Use Identity Mapper)";
private final StringProperty outputValue;
public @Inject TypeMapperComponent typeMappers;
public TypeMapperPropertyEditor() {
this.outputValue = new SimpleStringProperty();
}
@Override
public Stream<Item> fieldsFor(T document) {<FILL_FUNCTION_BODY>}
}
|
final String currentValue = document.getTypeMapper().orElse(null);
final Class<?> type = document.findDatabaseType();
final Map<String, String> mapping = MapStream.fromStream(
typeMappers.mapFrom(type).filter(TypeMapper::isToolApplicable),
TypeMapper::getLabel,
tm -> tm.getClass().getName()
).toSortedMap();
final ObservableList<String> alternatives = FXCollections.observableList(
new ArrayList<>(mapping.keySet())
);
alternatives.add(0, IDENTITY_MAPPER);
//Create a binding that will convert the ChoiceBox's value to a valid
//value for the document.typeMapperProperty()
StringBinding binding = Bindings.createStringBinding(() -> {
if (outputValue.isEmpty().get() || outputValue.get().equals(IDENTITY_MAPPER)) {
return null;
} else {
return mapping.get(outputValue.get());
}
}, outputValue);
document.typeMapperProperty().bind(binding);
outputValue.set(
currentValue != null
? MapStream.of(mapping)
.filterValue(currentValue::equals)
.keys()
.findAny()
.orElseThrow(() -> new RuntimeException(
"Could not find requested value '" + currentValue + "' in mapping."
))
: null );
return Stream.of(new ChoiceBoxItem<String>(
"JDBC Type to Java",
outputValue,
alternatives,
"The class that will be used to map types between the database and the generated code."
)
);
| 130
| 431
| 561
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-propertyeditor/src/main/java/com/speedment/tool/propertyeditor/editor/UniquePropertyEditor.java
|
UniquePropertyEditor
|
fieldsFor
|
class UniquePropertyEditor<T extends IndexProperty> implements PropertyEditor<T>{
@Override
public Stream<Item> fieldsFor(T document) {<FILL_FUNCTION_BODY>}
}
|
return Stream.of(new SimpleCheckBoxItem(
"Is Unique",
document.uniqueProperty(),
"True if elements in this index are unique.",
editor -> ItemUtil.lockDecorator(editor, document, ItemUtil.DATABASE_RELATION_TOOLTIP)
)
);
| 54
| 83
| 137
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-propertyeditor/src/main/java/com/speedment/tool/propertyeditor/editor/UsernamePropertyEditor.java
|
UsernamePropertyEditor
|
fieldsFor
|
class UsernamePropertyEditor<T extends DbmsProperty> implements PropertyEditor<T>{
@Override
public Stream<Item> fieldsFor(T document) {<FILL_FUNCTION_BODY>}
}
|
return Stream.of(new SimpleTextFieldItem(
"Username",
document.usernameProperty(),
"The username to use when connecting to the database."
)
);
| 54
| 50
| 104
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-propertyeditor/src/main/java/com/speedment/tool/propertyeditor/item/AbstractLabelTooltipItem.java
|
AbstractLabelTooltipItem
|
attachListener
|
class AbstractLabelTooltipItem implements PropertyEditor.Item {
protected static final UnaryOperator<Node> NO_DECORATOR = n -> n;
private final String label;
private final String tooltip;
private final Map<ObservableValue<Object>, ChangeListener<Object>> listeners;
private final UnaryOperator<Node> editorDecorator;
/**
* Creates an instance of this class. This constructor lets the caller
* supply a decorator that will be applied to the created editor.
*
* @param label the description label text
* @param tooltip the tooltip text
* @param editorDecorator the editor decorator
*/
protected AbstractLabelTooltipItem(String label, String tooltip, UnaryOperator<Node> editorDecorator){
requireNonNull(label, "A label must be assigned.");
requireNonNull(tooltip, "A tooltip must be assigned");
requireNonNull(editorDecorator, "An editor decorator must be assigned");
this.label = label;
this.tooltip = tooltip;
this.editorDecorator = editorDecorator;
this.listeners = new HashMap<>();
}
@Override
public Node createLabel() {
final Label l = new Label(label);
l.setTooltip( new Tooltip(tooltip) );
return l;
}
@Override
public final Node createEditor() {
final Node editor = createUndecoratedEditor();
return editorDecorator.apply(editor);
}
@Override
public final void onRemove(){
listeners.forEach(ObservableValue::removeListener);
}
/**
* Creates an editor without applying any decorators. This is called
* internally by the base class to produce a decorated editor.
*
* @return the created editor
*/
protected abstract Node createUndecoratedEditor();
/**
* Attaches a ChangeListener to the ObservableValue, and also stores their relationship.
* <p>
* Knowledge of their relationship is used when this PropertyEditor.Item is
* removed from the PropertySheet, to detach the listeners again. This will avoid
* memory leaks, as listeners otherwise prevent the observable from being garbage
* collected.
*
* @param <T> type of the ObservableValue and the ChangeListener
* @param observable the ObservableValue
* @param listener the ChangeListener
*/
protected final <T> void attachListener(ObservableValue<T> observable, ChangeListener<T> listener) {<FILL_FUNCTION_BODY>}
}
|
@SuppressWarnings("unchecked")
final ObservableValue<Object> key = (ObservableValue<Object>) observable;
@SuppressWarnings("unchecked")
final ChangeListener<Object> value = (ChangeListener<Object>) listener;
listeners.put(key, value);
observable.addListener(listener);
| 672
| 91
| 763
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-propertyeditor/src/main/java/com/speedment/tool/propertyeditor/item/ChoiceBoxItem.java
|
ChoiceBoxItem
|
createUndecoratedEditor
|
class ChoiceBoxItem<T> extends AbstractLabelTooltipItem {
private final Property<T> currentValue;
private final ObservableList<T> alternatives;
/**
* Creates a new ChoiceBoxItem.
* <p>
* The default choice will either be the first choice alternative, or the
* alternative matching the current value of the property (if such as
* alternative exists). Alternatives will get their name by calling toString()
* on the objects in the list of alternatives
* <p>
* The property will bind to the ChoiceBox.valueProperty().
*
* @param label the label text
* @param value the property
* @param alternatives list of alternatives in the choice box
* @param tooltip the tooltip
*/
public ChoiceBoxItem(
String label,
Property<T> value,
ObservableList<T> alternatives,
String tooltip) {
this(label, value, alternatives, tooltip, NO_DECORATOR);
}
/**
* Creates a new ChoiceBoxItem.
* <p>
* The default choice will either be the first choice alternative, or the
* alternative matching the current value of the property (if such as
* alternative exists). Alternatives will get their name by calling toString()
* on the objects in the list of alternatives
* <p>
* The property will bind to the ChoiceBox.valueProperty().
*
* @param label the label text
* @param value the property
* @param alternatives list of alternatives in the choice box
* @param tooltip the tooltip
* @param decorator the editor decorator
*/
public ChoiceBoxItem(
String label,
Property<T> value,
ObservableList<T> alternatives,
String tooltip,
UnaryOperator<Node> decorator) {
super(label, tooltip, decorator);
this.currentValue = value;
this.alternatives = FXCollections.unmodifiableObservableList(alternatives);
}
@Override
protected Node createUndecoratedEditor() {<FILL_FUNCTION_BODY>}
}
|
final ChoiceBox<T> box = new ChoiceBox<>(alternatives);
final T val = currentValue.getValue();
if (alternatives.contains(val)) {
box.setValue(val);
} else {
box.setValue(alternatives.get(0));
}
currentValue.bindBidirectional(box.valueProperty());
return box;
| 554
| 100
| 654
|
<methods>public final javafx.scene.Node createEditor() ,public javafx.scene.Node createLabel() ,public final void onRemove() <variables>protected static final UnaryOperator<javafx.scene.Node> NO_DECORATOR,private final non-sealed UnaryOperator<javafx.scene.Node> editorDecorator,private final non-sealed java.lang.String label,private final non-sealed Map<ObservableValue<java.lang.Object>,ChangeListener<java.lang.Object>> listeners,private final non-sealed java.lang.String tooltip
|
speedment_speedment
|
speedment/tool-parent/tool-propertyeditor/src/main/java/com/speedment/tool/propertyeditor/item/ItemUtil.java
|
ItemUtil
|
lockDecorator
|
class ItemUtil {
private ItemUtil() {}
public static final String DATABASE_RELATION_TOOLTIP =
"This field should ONLY be changed to reflect changes made in the underlying database.\nEnable editing by by right clicking on the field.";
/**
* Makes a node disabled by default, and requires that the user right-clicks
* the node to enable it.
* <p>
* This decorator is intended to use on fields that can be edited, but
* should only be edited under certain conditions, such as the Table.Name
* field
*
* @param node the node to decorate
* @param doc the document
* @param tooltipText the tooltip text displayed while the node is disabled
* @return the decorated node, which will be wrapped in a StackPane
*/
public static Node lockDecorator(Node node, Document doc, String tooltipText) {<FILL_FUNCTION_BODY>}
}
|
if (doc instanceof HasNameProtectedProperty
&& !((HasNameProtectedProperty) doc).isNameProtected()) return node;
node.setDisable(true);
final StackPane pane = new StackPane();
final ContextMenu menu = new ContextMenu();
final MenuItem item = new MenuItem("Enable editing");
final Tooltip tooltip = new Tooltip(tooltipText);
Tooltip.install(pane, tooltip);
menu.getItems().add(item);
final EventHandler<MouseEvent> contextMenuToggle = (MouseEvent event) -> {
if (event.isSecondaryButtonDown() && !menu.isShowing()) {
menu.show(pane, event.getScreenX(), event.getScreenY());
} else if (menu.isShowing()) {
menu.hide();
}
event.consume();
};
final EventHandler<ActionEvent> menuItemClicked = (ActionEvent event) -> {
Tooltip.uninstall(pane, tooltip);
pane.removeEventHandler(MouseEvent.MOUSE_PRESSED, contextMenuToggle);
node.setDisable(false);
if (doc instanceof HasNameProtectedProperty) {
((HasNameProtectedProperty) doc)
.nameProtectedProperty().set(false);
}
};
item.setOnAction(menuItemClicked);
pane.setOnMousePressed(contextMenuToggle);
pane.getChildren().add(node);
return pane;
| 243
| 390
| 633
|
<no_super_class>
|
speedment_speedment
|
speedment/tool-parent/tool-propertyeditor/src/main/java/com/speedment/tool/propertyeditor/item/NullableItem.java
|
NullableItem
|
createUndecoratedEditor
|
class NullableItem extends AbstractLabelTooltipItem {
private static final String NULLABLE_TITLE = "Is Nullable";
private static final String NULLABLE_TOOLTIP = "If this node can hold 'null'-values or not.";
private static final String IMPLEMENTATION_TITLE = "If this node can hold 'null'-values or not.";
private static final String IMPLEMENTATION_TOOLTIP = "How the nullable column should be implemented, either by " +
"using an Optional or by using a wrapper class that can have " +
"a null value.";
private final Document document;
private final BooleanProperty nullable;
private final ObjectProperty<ImplementAs> implementation;
public NullableItem(Document document, BooleanProperty nullable, ObjectProperty<ImplementAs> implementation) {
super(
NULLABLE_TITLE,
NULLABLE_TOOLTIP,
NO_DECORATOR
);
this.document = requireNonNull(document);
this.nullable = requireNonNull(nullable);
this.implementation = requireNonNull(implementation);
}
@Override
protected Node createUndecoratedEditor() {<FILL_FUNCTION_BODY>}
}
|
final CheckBox cbNull = new CheckBox();
final Node wrappedCb = ItemUtil.lockDecorator(cbNull, document, ItemUtil.DATABASE_RELATION_TOOLTIP);
final Label label = new Label(IMPLEMENTATION_TITLE);
final ChoiceBox<ImplementAs> cbImpl = new ChoiceBox<>(
observableArrayList(ImplementAs.values())
);
cbImpl.setTooltip(new Tooltip(IMPLEMENTATION_TOOLTIP));
final HBox right = new HBox(label, cbImpl);
final HBox left = new HBox(wrappedCb, right);
left.setSpacing(16);
right.setSpacing(8);
right.setAlignment(Pos.CENTER);
cbNull.selectedProperty().bindBidirectional(nullable);
cbImpl.valueProperty().bindBidirectional(implementation);
right.visibleProperty().bind(nullable);
right.disableProperty().bind(nullable.not());
return left;
| 318
| 276
| 594
|
<methods>public final javafx.scene.Node createEditor() ,public javafx.scene.Node createLabel() ,public final void onRemove() <variables>protected static final UnaryOperator<javafx.scene.Node> NO_DECORATOR,private final non-sealed UnaryOperator<javafx.scene.Node> editorDecorator,private final non-sealed java.lang.String label,private final non-sealed Map<ObservableValue<java.lang.Object>,ChangeListener<java.lang.Object>> listeners,private final non-sealed java.lang.String tooltip
|
speedment_speedment
|
speedment/tool-parent/tool-propertyeditor/src/main/java/com/speedment/tool/propertyeditor/item/SimpleCheckBoxItem.java
|
SimpleCheckBoxItem
|
createUndecoratedEditor
|
class SimpleCheckBoxItem extends AbstractLabelTooltipItem{
private final BooleanProperty property;
/**
* Creates a new SimpleCheckBoxItem. The property will bind to the
* editor node's CheckBox.selectedProperty()
*
* @param label the label text
* @param property the property to edit
* @param tooltip the tooltip text
*/
public SimpleCheckBoxItem(String label, BooleanProperty property, String tooltip){
this(label, property, tooltip, NO_DECORATOR);
}
/**
* Creates a new SimpleCheckBoxItem. The property will bind to the
* editor node's CheckBox.selectedProperty()
*
* @param label the label text
* @param property the property to edit
* @param tooltip the tooltip text
* @param decorator the editor decorator
*/
public SimpleCheckBoxItem(
String label,
BooleanProperty property,
String tooltip,
UnaryOperator<Node> decorator) {
super(label, tooltip, decorator);
this.property = property;
}
@Override
protected Node createUndecoratedEditor() {<FILL_FUNCTION_BODY>}
}
|
final CheckBox box = new CheckBox();
box.setSelected( property.get() );
property.bindBidirectional(box.selectedProperty() );
return box;
| 326
| 48
| 374
|
<methods>public final javafx.scene.Node createEditor() ,public javafx.scene.Node createLabel() ,public final void onRemove() <variables>protected static final UnaryOperator<javafx.scene.Node> NO_DECORATOR,private final non-sealed UnaryOperator<javafx.scene.Node> editorDecorator,private final non-sealed java.lang.String label,private final non-sealed Map<ObservableValue<java.lang.Object>,ChangeListener<java.lang.Object>> listeners,private final non-sealed java.lang.String tooltip
|
speedment_speedment
|
speedment/tool-parent/tool-propertyeditor/src/main/java/com/speedment/tool/propertyeditor/item/SimpleTextFieldItem.java
|
SimpleTextFieldItem
|
createUndecoratedEditor
|
class SimpleTextFieldItem extends AbstractLabelTooltipItem {
private final StringProperty property;
/**
* Creates a new SimpleTextFieldItem. The property will bind to the
* editor node's TextField.textProperty()
*
* @param label this editor's label text
* @param property the property to edit
* @param tooltip this editor's tooltip text
*/
public SimpleTextFieldItem(String label, StringProperty property, String tooltip) {
this(label, property, tooltip, NO_DECORATOR);
}
/**
* Creates a new SimpleTextFieldItem. The property will bind to the
* editor node's TextField.textProperty()
*
* @param label this editor's label text
* @param property the property to edit
* @param tooltip this editor's tooltip text
* @param decorator the editor decorator
*/
public SimpleTextFieldItem(String label, StringProperty property, String tooltip, UnaryOperator<Node> decorator) {
super(label, tooltip, decorator);
this.property = property;
}
@Override
protected Node createUndecoratedEditor() {<FILL_FUNCTION_BODY>}
}
|
final TextField box = new TextField( property.get() );
property.bindBidirectional(box.textProperty() );
return box;
| 327
| 40
| 367
|
<methods>public final javafx.scene.Node createEditor() ,public javafx.scene.Node createLabel() ,public final void onRemove() <variables>protected static final UnaryOperator<javafx.scene.Node> NO_DECORATOR,private final non-sealed UnaryOperator<javafx.scene.Node> editorDecorator,private final non-sealed java.lang.String label,private final non-sealed Map<ObservableValue<java.lang.Object>,ChangeListener<java.lang.Object>> listeners,private final non-sealed java.lang.String tooltip
|
spring-projects_spring-batch
|
spring-batch/spring-batch-core/src/main/java/org/springframework/batch/core/DefaultJobKeyGenerator.java
|
DefaultJobKeyGenerator
|
generateKey
|
class DefaultJobKeyGenerator implements JobKeyGenerator<JobParameters> {
/**
* Generates the job key to be used based on the {@link JobParameters} instance
* provided.
*/
@Override
public String generateKey(JobParameters source) {<FILL_FUNCTION_BODY>}
}
|
Assert.notNull(source, "source must not be null");
Map<String, JobParameter<?>> props = source.getParameters();
StringBuilder stringBuffer = new StringBuilder();
List<String> keys = new ArrayList<>(props.keySet());
Collections.sort(keys);
for (String key : keys) {
JobParameter<?> jobParameter = props.get(key);
if (jobParameter.isIdentifying()) {
String value = jobParameter.toString();
stringBuffer.append(key).append("=").append(value).append(";");
}
}
return DigestUtils.md5DigestAsHex(stringBuffer.toString().getBytes(StandardCharsets.UTF_8));
| 75
| 186
| 261
|
<no_super_class>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.