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
|
|---|---|---|---|---|---|---|---|---|---|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/common/NodeBuildHelper.java
|
NodeBuildHelper
|
reserveTupleStoreIndex
|
class NodeBuildHelper<Score_ extends Score<Score_>> {
private final Set<? extends ConstraintStream> activeStreamSet;
private final Map<Constraint, Score_> constraintWeightMap;
private final AbstractScoreInliner<Score_> scoreInliner;
private final Map<ConstraintStream, TupleLifecycle<? extends Tuple>> tupleLifecycleMap;
private final Map<ConstraintStream, Integer> storeIndexMap;
private List<AbstractNode> reversedNodeList;
public NodeBuildHelper(Set<? extends ConstraintStream> activeStreamSet, Map<Constraint, Score_> constraintWeightMap,
AbstractScoreInliner<Score_> scoreInliner) {
this.activeStreamSet = activeStreamSet;
this.constraintWeightMap = constraintWeightMap;
this.scoreInliner = scoreInliner;
int activeStreamSetSize = activeStreamSet.size();
this.tupleLifecycleMap = new HashMap<>(Math.max(16, activeStreamSetSize));
this.storeIndexMap = new HashMap<>(Math.max(16, activeStreamSetSize / 2));
this.reversedNodeList = new ArrayList<>(activeStreamSetSize);
}
public boolean isStreamActive(ConstraintStream stream) {
return activeStreamSet.contains(stream);
}
public AbstractScoreInliner<Score_> getScoreInliner() {
return scoreInliner;
}
public Score_ getConstraintWeight(Constraint constraint) {
return constraintWeightMap.get(constraint);
}
public void addNode(AbstractNode node) {
reversedNodeList.add(node);
}
public void addNode(AbstractNode node, ConstraintStream parent) {
addNode(node);
putInsertUpdateRetract(parent, (TupleLifecycle<? extends Tuple>) node);
}
public void addNode(AbstractNode node, ConstraintStream leftParent, ConstraintStream rightParent) {
addNode(node);
putInsertUpdateRetract(leftParent, TupleLifecycle.ofLeft((LeftTupleLifecycle<? extends Tuple>) node));
putInsertUpdateRetract(rightParent, TupleLifecycle.ofRight((RightTupleLifecycle<? extends Tuple>) node));
}
public <Tuple_ extends Tuple> void putInsertUpdateRetract(ConstraintStream stream, TupleLifecycle<Tuple_> tupleLifecycle) {
tupleLifecycleMap.put(stream, tupleLifecycle);
}
public <Tuple_ extends Tuple> void putInsertUpdateRetract(ConstraintStream stream,
List<? extends AbstractConstraintStream> childStreamList,
Function<TupleLifecycle<Tuple_>, AbstractConditionalTupleLifecycle<Tuple_>> tupleLifecycleFunction) {
TupleLifecycle<Tuple_> tupleLifecycle = getAggregatedTupleLifecycle(childStreamList);
putInsertUpdateRetract(stream, tupleLifecycleFunction.apply(tupleLifecycle));
}
public <Tuple_ extends Tuple> TupleLifecycle<Tuple_> getAggregatedTupleLifecycle(
List<? extends ConstraintStream> streamList) {
TupleLifecycle<Tuple_>[] tupleLifecycles = streamList.stream()
.filter(this::isStreamActive)
.map(s -> getTupleLifecycle(s, tupleLifecycleMap))
.toArray(TupleLifecycle[]::new);
switch (tupleLifecycles.length) {
case 0:
throw new IllegalStateException("Impossible state: None of the streamList (" + streamList
+ ") are active.");
case 1:
return tupleLifecycles[0];
default:
return new AggregatedTupleLifecycle<>(tupleLifecycles);
}
}
private static <Tuple_ extends Tuple> TupleLifecycle<Tuple_> getTupleLifecycle(ConstraintStream stream,
Map<ConstraintStream, TupleLifecycle<? extends Tuple>> tupleLifecycleMap) {
TupleLifecycle<Tuple_> tupleLifecycle = (TupleLifecycle<Tuple_>) tupleLifecycleMap.get(stream);
if (tupleLifecycle == null) {
throw new IllegalStateException("Impossible state: the stream (" + stream + ") hasn't built a node yet.");
}
return tupleLifecycle;
}
public int reserveTupleStoreIndex(ConstraintStream tupleSourceStream) {<FILL_FUNCTION_BODY>}
public int extractTupleStoreSize(ConstraintStream tupleSourceStream) {
Integer lastIndex = storeIndexMap.put(tupleSourceStream, Integer.MIN_VALUE);
return (lastIndex == null) ? 0 : lastIndex + 1;
}
public List<AbstractNode> destroyAndGetNodeList() {
List<AbstractNode> nodeList = this.reversedNodeList;
Collections.reverse(nodeList);
this.reversedNodeList = null;
return nodeList;
}
}
|
return storeIndexMap.compute(tupleSourceStream, (k, index) -> {
if (index == null) {
return 0;
} else if (index < 0) {
throw new IllegalStateException("Impossible state: the tupleSourceStream (" + k
+ ") is reserving a store after it has been extracted.");
} else {
return index + 1;
}
});
| 1,330
| 103
| 1,433
|
<no_super_class>
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/common/collection/TupleList.java
|
TupleList
|
remove
|
class TupleList<T> {
private int size = 0;
private TupleListEntry<T> first = null;
private TupleListEntry<T> last = null;
public TupleListEntry<T> add(T tuple) {
TupleListEntry<T> entry = new TupleListEntry<>(this, tuple, last);
if (first == null) {
first = entry;
} else {
last.next = entry;
}
last = entry;
size++;
return entry;
}
public void remove(TupleListEntry<T> entry) {<FILL_FUNCTION_BODY>}
public TupleListEntry<T> first() {
return first;
}
public TupleListEntry<T> last() {
return last;
}
public int size() {
return size;
}
public void forEach(Consumer<T> tupleConsumer) {
TupleListEntry<T> entry = first;
while (entry != null) {
// Extract next before processing it, in case the entry is removed and entry.next becomes null
TupleListEntry<T> next = entry.next;
tupleConsumer.accept(entry.getElement());
entry = next;
}
}
@Override
public String toString() {
return "size = " + size;
}
}
|
if (first == entry) {
first = entry.next;
} else {
entry.previous.next = entry.next;
}
if (last == entry) {
last = entry.previous;
} else {
entry.next.previous = entry.previous;
}
entry.previous = null;
entry.next = null;
size--;
| 354
| 98
| 452
|
<no_super_class>
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/common/collection/TupleListEntry.java
|
TupleListEntry
|
removeAndNext
|
class TupleListEntry<T> {
private TupleList<T> list;
private final T element;
TupleListEntry<T> previous;
TupleListEntry<T> next;
TupleListEntry(TupleList<T> list, T element, TupleListEntry<T> previous) {
this.list = list;
this.element = element;
this.previous = previous;
this.next = null;
}
public TupleListEntry<T> next() {
return next;
}
public TupleListEntry<T> removeAndNext() {<FILL_FUNCTION_BODY>}
public void remove() {
if (list == null) {
throw new IllegalStateException("The element (" + element + ") was already removed.");
}
list.remove(this);
list = null;
}
public T getElement() {
return element;
}
public TupleList<T> getList() {
return list;
}
@Override
public String toString() {
return element.toString();
}
}
|
TupleListEntry<T> next = this.next;
remove(); // Sets this.next = null
return next;
| 286
| 34
| 320
|
<no_super_class>
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/common/index/ComparisonIndexer.java
|
ComparisonIndexer
|
size
|
class ComparisonIndexer<T, Key_ extends Comparable<Key_>> implements Indexer<T> {
private final int indexKeyPosition;
private final Supplier<Indexer<T>> downstreamIndexerSupplier;
private final Comparator<Key_> keyComparator;
private final boolean hasOrEquals;
private final NavigableMap<Key_, Indexer<T>> comparisonMap;
public ComparisonIndexer(JoinerType comparisonJoinerType, Supplier<Indexer<T>> downstreamIndexerSupplier) {
this(comparisonJoinerType, 0, downstreamIndexerSupplier);
}
public ComparisonIndexer(JoinerType comparisonJoinerType, int indexKeyPosition,
Supplier<Indexer<T>> downstreamIndexerSupplier) {
this.indexKeyPosition = indexKeyPosition;
this.downstreamIndexerSupplier = Objects.requireNonNull(downstreamIndexerSupplier);
/*
* For GT/GTE, the iteration order is reversed.
* This allows us to iterate over the entire map, stopping when the threshold is reached.
* This is done so that we can avoid using head/tail sub maps, which are expensive.
*/
this.keyComparator =
(comparisonJoinerType == JoinerType.GREATER_THAN || comparisonJoinerType == JoinerType.GREATER_THAN_OR_EQUAL)
? KeyComparator.INSTANCE.reversed()
: KeyComparator.INSTANCE;
this.hasOrEquals = comparisonJoinerType == JoinerType.GREATER_THAN_OR_EQUAL
|| comparisonJoinerType == JoinerType.LESS_THAN_OR_EQUAL;
this.comparisonMap = new TreeMap<>(keyComparator);
}
@Override
public TupleListEntry<T> put(IndexProperties indexProperties, T tuple) {
Key_ indexKey = indexProperties.toKey(indexKeyPosition);
// Avoids computeIfAbsent in order to not create lambdas on the hot path.
Indexer<T> downstreamIndexer = comparisonMap.get(indexKey);
if (downstreamIndexer == null) {
downstreamIndexer = downstreamIndexerSupplier.get();
comparisonMap.put(indexKey, downstreamIndexer);
}
return downstreamIndexer.put(indexProperties, tuple);
}
@Override
public void remove(IndexProperties indexProperties, TupleListEntry<T> entry) {
Key_ indexKey = indexProperties.toKey(indexKeyPosition);
Indexer<T> downstreamIndexer = getDownstreamIndexer(indexProperties, indexKey, entry);
downstreamIndexer.remove(indexProperties, entry);
if (downstreamIndexer.isEmpty()) {
comparisonMap.remove(indexKey);
}
}
private Indexer<T> getDownstreamIndexer(IndexProperties indexProperties, Key_ indexerKey,
TupleListEntry<T> entry) {
Indexer<T> downstreamIndexer = comparisonMap.get(indexerKey);
if (downstreamIndexer == null) {
throw new IllegalStateException("Impossible state: the tuple (" + entry.getElement()
+ ") with indexProperties (" + indexProperties
+ ") doesn't exist in the indexer " + this + ".");
}
return downstreamIndexer;
}
// TODO clean up DRY
@Override
public int size(IndexProperties indexProperties) {<FILL_FUNCTION_BODY>}
@Override
public void forEach(IndexProperties indexProperties, Consumer<T> tupleConsumer) {
int size = comparisonMap.size();
if (size == 0) {
return;
}
Key_ indexKey = indexProperties.toKey(indexKeyPosition);
if (size == 1) { // Avoid creation of the entry set and iterator.
Map.Entry<Key_, Indexer<T>> entry = comparisonMap.firstEntry();
visitEntry(indexProperties, tupleConsumer, indexKey, entry);
} else {
for (Map.Entry<Key_, Indexer<T>> entry : comparisonMap.entrySet()) {
boolean boundaryReached = visitEntry(indexProperties, tupleConsumer, indexKey, entry);
if (boundaryReached) {
return;
}
}
}
}
private boolean visitEntry(IndexProperties indexProperties, Consumer<T> tupleConsumer,
Key_ indexKey, Map.Entry<Key_, Indexer<T>> entry) {
// Comparator matches the order of iteration of the map, so the boundary is always found from the bottom up.
int comparison = keyComparator.compare(entry.getKey(), indexKey);
if (comparison >= 0) { // Possibility of reaching the boundary condition.
if (comparison > 0 || !hasOrEquals) {
// Boundary condition reached when we're out of bounds entirely, or when GTE/LTE is not allowed.
return true;
}
}
// Boundary condition not yet reached; include the indexer in the range.
entry.getValue().forEach(indexProperties, tupleConsumer);
return false;
}
@Override
public boolean isEmpty() {
return comparisonMap.isEmpty();
}
@Override
public String toString() {
return "size = " + comparisonMap.size();
}
private static final class KeyComparator<Key_ extends Comparable<Key_>> implements Comparator<Key_> {
private static final Comparator INSTANCE = new KeyComparator<>();
@Override
public int compare(Key_ o1, Key_ o2) {
if (o1 == o2) {
return 0;
}
return o1.compareTo(o2);
}
}
}
|
int mapSize = comparisonMap.size();
if (mapSize == 0) {
return 0;
}
Key_ indexKey = indexProperties.toKey(indexKeyPosition);
if (mapSize == 1) { // Avoid creation of the entry set and iterator.
Map.Entry<Key_, Indexer<T>> entry = comparisonMap.firstEntry();
int comparison = keyComparator.compare(entry.getKey(), indexKey);
if (comparison >= 0) { // Possibility of reaching the boundary condition.
if (comparison > 0 || !hasOrEquals) {
// Boundary condition reached when we're out of bounds entirely, or when GTE/LTE is not allowed.
return 0;
}
}
return entry.getValue().size(indexProperties);
} else {
int size = 0;
for (Map.Entry<Key_, Indexer<T>> entry : comparisonMap.entrySet()) {
int comparison = keyComparator.compare(entry.getKey(), indexKey);
if (comparison >= 0) { // Possibility of reaching the boundary condition.
if (comparison > 0 || !hasOrEquals) {
// Boundary condition reached when we're out of bounds entirely, or when GTE/LTE is not allowed.
break;
}
}
// Boundary condition not yet reached; include the indexer in the range.
size += entry.getValue().size(indexProperties);
}
return size;
}
| 1,457
| 372
| 1,829
|
<no_super_class>
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/common/index/IndexerFactory.java
|
IndexerFactory
|
buildIndexer
|
class IndexerFactory {
private final JoinerType[] joinerTypes;
public IndexerFactory(AbstractJoiner joiner) {
int joinerCount = joiner.getJoinerCount();
joinerTypes = new JoinerType[joinerCount];
for (int i = 0; i < joinerCount; i++) {
JoinerType joinerType = joiner.getJoinerType(i);
switch (joinerType) {
case EQUAL:
case LESS_THAN:
case LESS_THAN_OR_EQUAL:
case GREATER_THAN:
case GREATER_THAN_OR_EQUAL:
break;
default:
throw new UnsupportedOperationException("Unsupported joiner type (" + joinerType + ").");
}
joinerTypes[i] = joiner.getJoinerType(i);
}
}
public boolean hasJoiners() {
return joinerTypes.length > 0;
}
public <T> Indexer<T> buildIndexer(boolean isLeftBridge) {<FILL_FUNCTION_BODY>}
}
|
/*
* Indexers form a parent-child hierarchy, each child has exactly one parent.
* NoneIndexer is always at the bottom of the hierarchy, never a parent unless it is the only indexer.
* Parent indexers delegate to their children, until they reach the ultimate NoneIndexer.
* Example 1: EQUAL+LESS_THAN joiner will become EqualsIndexer -> ComparisonIndexer -> NoneIndexer.
*
* Note that if creating indexer for a right bridge node, the joiner type has to be flipped.
* (<A, B> becomes <B, A>.)
*/
if (joinerTypes.length == 0) { // NoneJoiner results in NoneIndexer.
return new NoneIndexer<>();
} else if (joinerTypes.length == 1) { // Single joiner maps directly to EqualsIndexer or ComparisonIndexer.
JoinerType joinerType = joinerTypes[0];
if (joinerType == JoinerType.EQUAL) {
return new EqualsIndexer<>(NoneIndexer::new);
} else {
return new ComparisonIndexer<>(isLeftBridge ? joinerType : joinerType.flip(), NoneIndexer::new);
}
}
/*
* For more than 1 joiner, we need to build the actual hierarchy. The following rules apply:
*
* Rule 1: Two or more consecutive EQUAL joiners become a single EqualsIndexer.
* Example: EQUAL+EQUAL+LESS_THAN results in EqualsIndexer -> ComparisonIndexer.
*
* Rule 2: Once a joiner type in the sequence changes (from EQUALS to comparison or vice versa),
* the joiner on the right results in an indexer that is a child to the indexer of the joiner on the left.
* Example: EQUAL+LESS_THAN+EQUAL results in EqualsIndexer -> ComparisonIndexer -> EqualsIndexer.
*
* The following code builds the children first, so it needs to iterate over the joiners in reverse order.
*/
NavigableMap<Integer, JoinerType> joinerTypeMap = new TreeMap<>();
for (int i = 1; i <= joinerTypes.length; i++) {
JoinerType joinerType = i < joinerTypes.length ? joinerTypes[i] : null;
JoinerType previousJoinerType = joinerTypes[i - 1];
if (joinerType != JoinerType.EQUAL || previousJoinerType != joinerType) {
joinerTypeMap.put(i, previousJoinerType);
}
}
NavigableMap<Integer, JoinerType> descendingJoinerTypeMap = joinerTypeMap.descendingMap();
Supplier<Indexer<T>> downstreamIndexerSupplier = NoneIndexer::new;
for (Map.Entry<Integer, JoinerType> entry : descendingJoinerTypeMap.entrySet()) {
Integer endingPropertyExclusive = entry.getKey();
Integer previousEndingPropertyExclusiveOrNull = descendingJoinerTypeMap.higherKey(endingPropertyExclusive);
int previousEndingPropertyExclusive =
previousEndingPropertyExclusiveOrNull == null ? 0 : previousEndingPropertyExclusiveOrNull;
JoinerType joinerType = entry.getValue();
Supplier<Indexer<T>> actualDownstreamIndexerSupplier = downstreamIndexerSupplier;
if (joinerType == JoinerType.EQUAL) {
/*
* Equals indexer keys may span multiple index properties, one for each EQUALS joiner.
*
* Example 1: For an EQUAL+LESS_THAN joiner, indexer key is of length 1 and starts at position 0.
* Example 2: For an LESS_THAN+EQUAL+EQUAL joiner, indexer key is of length 2 and starts at position 1.
*/
if (endingPropertyExclusive <= previousEndingPropertyExclusive) {
throw new IllegalStateException("Impossible state: index key ending position <= starting position ("
+ endingPropertyExclusive + " <= " + previousEndingPropertyExclusive + ")");
}
downstreamIndexerSupplier = () -> new EqualsIndexer<>(previousEndingPropertyExclusive, endingPropertyExclusive,
actualDownstreamIndexerSupplier);
} else {
JoinerType actualJoinerType = isLeftBridge ? joinerType : joinerType.flip();
/*
* Comparison indexers only ever have one comparison key.
* Its position is the next one immediately following the preceding EQUALS position,
* or the first one if there are no preceding EQUALS joiners.
*
* Example 1: For an EQUAL+LESS_THAN joiner, comparison key is on position 1.
* Example 2: For an EQUAL+EQUAL+LESS_THAN joiner: comparison key is on position 2.
*/
downstreamIndexerSupplier = () -> new ComparisonIndexer<>(actualJoinerType, previousEndingPropertyExclusive,
actualDownstreamIndexerSupplier);
}
}
return downstreamIndexerSupplier.get();
| 289
| 1,297
| 1,586
|
<no_super_class>
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/common/index/SingleIndexProperties.java
|
SingleIndexProperties
|
equals
|
class SingleIndexProperties implements IndexProperties {
private final Object property;
SingleIndexProperties(Object property) {
this.property = property;
}
@Override
public <Type_> Type_ toKey(int index) {
if (index != 0) {
throw new IllegalArgumentException("Impossible state: index (" + index + ") != 0");
}
return (Type_) property;
}
@Override
public <Type_> Type_ toKey(int from, int to) {
if (to != 1) {
throw new IllegalArgumentException("Impossible state: key from (" + from + ") to (" + to + ").");
}
return toKey(from);
}
@Override
public boolean equals(Object o) {<FILL_FUNCTION_BODY>}
@Override
public int hashCode() { // Not using Objects.hash(Object...) as that would create an array on the hot path.
return Objects.hashCode(property);
}
@Override
public String toString() {
return "[" + property + "]";
}
}
|
if (this == o) {
return true;
}
if (!(o instanceof SingleIndexProperties)) {
return false;
}
SingleIndexProperties other = (SingleIndexProperties) o;
return Objects.equals(property, other.property);
| 284
| 68
| 352
|
<no_super_class>
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/common/index/ThreeIndexProperties.java
|
ThreeIndexProperties
|
toKey
|
class ThreeIndexProperties implements IndexProperties {
private final Object propertyA;
private final Object propertyB;
private final Object propertyC;
ThreeIndexProperties(Object propertyA, Object propertyB, Object propertyC) {
this.propertyA = propertyA;
this.propertyB = propertyB;
this.propertyC = propertyC;
}
@Override
public <Type_> Type_ toKey(int index) {
switch (index) {
case 0:
return (Type_) propertyA;
case 1:
return (Type_) propertyB;
case 2:
return (Type_) propertyC;
default:
throw new IllegalArgumentException("Impossible state: index (" + index + ") != 0");
}
}
@Override
public <Type_> Type_ toKey(int from, int to) {<FILL_FUNCTION_BODY>}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof ThreeIndexProperties)) {
return false;
}
ThreeIndexProperties other = (ThreeIndexProperties) o;
return Objects.equals(propertyA, other.propertyA)
&& Objects.equals(propertyB, other.propertyB)
&& Objects.equals(propertyC, other.propertyC);
}
@Override
public int hashCode() { // Not using Objects.hash(Object...) as that would create an array on the hot path.
int result = Objects.hashCode(propertyA);
result = 31 * result + Objects.hashCode(propertyB);
result = 31 * result + Objects.hashCode(propertyC);
return result;
}
@Override
public String toString() {
return "[" + propertyA + ", " + propertyB + ", " + propertyC + "]";
}
}
|
switch (to - from) {
case 1:
return toKey(from);
case 2:
return (Type_) Pair.of(toKey(from), toKey(from + 1));
case 3:
if (from != 0 || to != 3) {
throw new IllegalArgumentException("Impossible state: key from (" + from + ") to (" + to + ").");
}
return (Type_) this;
default:
throw new IllegalArgumentException("Impossible state: key from (" + from + ") to (" + to + ").");
}
| 479
| 146
| 625
|
<no_super_class>
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/common/index/TwoIndexProperties.java
|
TwoIndexProperties
|
toKey
|
class TwoIndexProperties implements IndexProperties {
private final Object propertyA;
private final Object propertyB;
TwoIndexProperties(Object propertyA, Object propertyB) {
this.propertyA = propertyA;
this.propertyB = propertyB;
}
@Override
public <Type_> Type_ toKey(int index) {<FILL_FUNCTION_BODY>}
@Override
public <Type_> Type_ toKey(int from, int to) {
switch (to - from) {
case 1:
return toKey(from);
case 2:
if (from != 0 || to != 2) {
throw new IllegalArgumentException("Impossible state: key from (" + from + ") to (" + to + ").");
}
return (Type_) this;
default:
throw new IllegalArgumentException("Impossible state: key from (" + from + ") to (" + to + ").");
}
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof TwoIndexProperties)) {
return false;
}
TwoIndexProperties other = (TwoIndexProperties) o;
return Objects.equals(propertyA, other.propertyA)
&& Objects.equals(propertyB, other.propertyB);
}
@Override
public int hashCode() { // Not using Objects.hash(Object...) as that would create an array on the hot path.
int result = Objects.hashCode(propertyA);
result = 31 * result + Objects.hashCode(propertyB);
return result;
}
@Override
public String toString() {
return "[" + propertyA + ", " + propertyB + "]";
}
}
|
switch (index) {
case 0:
return (Type_) propertyA;
case 1:
return (Type_) propertyB;
default:
throw new IllegalArgumentException("Impossible state: index (" + index + ") != 0");
}
| 451
| 68
| 519
|
<no_super_class>
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/quad/BavetBiGroupBridgeQuadConstraintStream.java
|
BavetBiGroupBridgeQuadConstraintStream
|
buildNode
|
class BavetBiGroupBridgeQuadConstraintStream<Solution_, A, B, C, D, NewA, NewB>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
private final BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent;
private BavetGroupBiConstraintStream<Solution_, NewA, NewB> groupStream;
private final GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor;
public BavetBiGroupBridgeQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent,
GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
this.nodeConstructor = nodeConstructor;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
public void setGroupStream(BavetGroupBiConstraintStream<Solution_, NewA, NewB> groupStream) {
this.groupStream = groupStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {<FILL_FUNCTION_BODY>}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parent.getTupleSource();
}
}
|
List<? extends ConstraintStream> groupStreamChildList = groupStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), groupStream, groupStreamChildList, this, childStreamList,
constraintFactory.getEnvironmentMode());
| 467
| 66
| 533
|
<methods>public void <init>(BavetConstraintFactory<Solution_>, org.optaplanner.constraint.streams.common.RetrievalSemantics) ,public BavetAbstractQuadConstraintStream<Solution_,A,B,C,D> filter(QuadPredicate<A,B,C,D>) ,public QuadConstraintStream<A,B,C,ResultD_> flattenLast(Function<D,Iterable<ResultD_>>) ,public List<BavetAbstractQuadConstraintStream<Solution_,A,B,C,D>> getChildStreamList() ,public UniConstraintStream<Result_> groupBy(QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_>) ,public BiConstraintStream<ResultA_,ResultB_> groupBy(QuadConstraintCollector<A,B,C,D,ResultContainerA_,ResultA_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>) ,public TriConstraintStream<ResultA_,ResultB_,ResultC_> groupBy(QuadConstraintCollector<A,B,C,D,ResultContainerA_,ResultA_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_> groupBy(QuadConstraintCollector<A,B,C,D,ResultContainerA_,ResultA_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>, QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_>) ,public UniConstraintStream<GroupKey_> groupBy(QuadFunction<A,B,C,D,GroupKey_>) ,public TriConstraintStream<GroupKey_,ResultB_,ResultC_> groupBy(QuadFunction<A,B,C,D,GroupKey_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_> groupBy(QuadFunction<A,B,C,D,GroupKey_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>, QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_>) ,public BiConstraintStream<GroupKey_,Result_> groupBy(QuadFunction<A,B,C,D,GroupKey_>, QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_>) ,public BiConstraintStream<GroupKeyA_,GroupKeyB_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>, QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadFunction<A,B,C,D,GroupKeyC_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadFunction<A,B,C,D,GroupKeyC_>, QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadFunction<A,B,C,D,GroupKeyC_>, QuadFunction<A,B,C,D,GroupKeyD_>) ,public final transient QuadConstraintStream<A,B,C,D> ifExists(Class<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifExists(UniConstraintStream<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifExistsIncludingNullVars(Class<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifNotExists(Class<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifNotExists(UniConstraintStream<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifNotExistsIncludingNullVars(Class<E>, PentaJoiner<A,B,C,D,E>[]) ,public QuadConstraintBuilder<A,B,C,D,Score_> innerImpact(Score_, ToIntQuadFunction<A,B,C,D>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public QuadConstraintBuilder<A,B,C,D,Score_> innerImpact(Score_, ToLongQuadFunction<A,B,C,D>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public QuadConstraintBuilder<A,B,C,D,Score_> innerImpact(Score_, QuadFunction<A,B,C,D,java.math.BigDecimal>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public UniConstraintStream<ResultA_> map(QuadFunction<A,B,C,D,ResultA_>) ,public Stream_ shareAndAddChild(Stream_) <variables>protected final List<BavetAbstractQuadConstraintStream<Solution_,A,B,C,D>> childStreamList
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/quad/BavetFilterQuadConstraintStream.java
|
BavetFilterQuadConstraintStream
|
buildNode
|
class BavetFilterQuadConstraintStream<Solution_, A, B, C, D>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
private final BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent;
private final QuadPredicate<A, B, C, D> predicate;
public BavetFilterQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent,
QuadPredicate<A, B, C, D> predicate) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
this.predicate = predicate;
if (predicate == null) {
throw new IllegalArgumentException("The predicate (null) cannot be null.");
}
}
@Override
public boolean guaranteesDistinct() {
return parent.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parent.getTupleSource();
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {<FILL_FUNCTION_BODY>}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public int hashCode() {
return Objects.hash(parent, predicate);
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
} else if (o instanceof BavetFilterQuadConstraintStream) {
BavetFilterQuadConstraintStream<?, ?, ?, ?, ?> other = (BavetFilterQuadConstraintStream<?, ?, ?, ?, ?>) o;
return parent == other.parent
&& predicate == other.predicate;
} else {
return false;
}
}
@Override
public String toString() {
return "Filter() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
buildHelper.<QuadTuple<A, B, C, D>> putInsertUpdateRetract(this, childStreamList,
tupleLifecycle -> new ConditionalQuadTupleLifecycle<>(predicate, tupleLifecycle));
| 653
| 65
| 718
|
<methods>public void <init>(BavetConstraintFactory<Solution_>, org.optaplanner.constraint.streams.common.RetrievalSemantics) ,public BavetAbstractQuadConstraintStream<Solution_,A,B,C,D> filter(QuadPredicate<A,B,C,D>) ,public QuadConstraintStream<A,B,C,ResultD_> flattenLast(Function<D,Iterable<ResultD_>>) ,public List<BavetAbstractQuadConstraintStream<Solution_,A,B,C,D>> getChildStreamList() ,public UniConstraintStream<Result_> groupBy(QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_>) ,public BiConstraintStream<ResultA_,ResultB_> groupBy(QuadConstraintCollector<A,B,C,D,ResultContainerA_,ResultA_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>) ,public TriConstraintStream<ResultA_,ResultB_,ResultC_> groupBy(QuadConstraintCollector<A,B,C,D,ResultContainerA_,ResultA_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_> groupBy(QuadConstraintCollector<A,B,C,D,ResultContainerA_,ResultA_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>, QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_>) ,public UniConstraintStream<GroupKey_> groupBy(QuadFunction<A,B,C,D,GroupKey_>) ,public TriConstraintStream<GroupKey_,ResultB_,ResultC_> groupBy(QuadFunction<A,B,C,D,GroupKey_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_> groupBy(QuadFunction<A,B,C,D,GroupKey_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>, QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_>) ,public BiConstraintStream<GroupKey_,Result_> groupBy(QuadFunction<A,B,C,D,GroupKey_>, QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_>) ,public BiConstraintStream<GroupKeyA_,GroupKeyB_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>, QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadFunction<A,B,C,D,GroupKeyC_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadFunction<A,B,C,D,GroupKeyC_>, QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadFunction<A,B,C,D,GroupKeyC_>, QuadFunction<A,B,C,D,GroupKeyD_>) ,public final transient QuadConstraintStream<A,B,C,D> ifExists(Class<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifExists(UniConstraintStream<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifExistsIncludingNullVars(Class<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifNotExists(Class<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifNotExists(UniConstraintStream<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifNotExistsIncludingNullVars(Class<E>, PentaJoiner<A,B,C,D,E>[]) ,public QuadConstraintBuilder<A,B,C,D,Score_> innerImpact(Score_, ToIntQuadFunction<A,B,C,D>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public QuadConstraintBuilder<A,B,C,D,Score_> innerImpact(Score_, ToLongQuadFunction<A,B,C,D>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public QuadConstraintBuilder<A,B,C,D,Score_> innerImpact(Score_, QuadFunction<A,B,C,D,java.math.BigDecimal>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public UniConstraintStream<ResultA_> map(QuadFunction<A,B,C,D,ResultA_>) ,public Stream_ shareAndAddChild(Stream_) <variables>protected final List<BavetAbstractQuadConstraintStream<Solution_,A,B,C,D>> childStreamList
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/quad/BavetFlattenLastQuadConstraintStream.java
|
BavetFlattenLastQuadConstraintStream
|
toString
|
class BavetFlattenLastQuadConstraintStream<Solution_, A, B, C, D>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
private final BavetAbstractConstraintStream<Solution_> parent;
public BavetFlattenLastQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractConstraintStream<Solution_> parent) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
}
@Override
public boolean guaranteesDistinct() {
return false;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
// Do nothing. BavetFlattenLastBridgeUniConstraintStream, etc build everything.
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
// TODO
@Override
public String toString() {<FILL_FUNCTION_BODY>}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
return "FlattenLast() with " + childStreamList.size() + " children";
| 380
| 25
| 405
|
<methods>public void <init>(BavetConstraintFactory<Solution_>, org.optaplanner.constraint.streams.common.RetrievalSemantics) ,public BavetAbstractQuadConstraintStream<Solution_,A,B,C,D> filter(QuadPredicate<A,B,C,D>) ,public QuadConstraintStream<A,B,C,ResultD_> flattenLast(Function<D,Iterable<ResultD_>>) ,public List<BavetAbstractQuadConstraintStream<Solution_,A,B,C,D>> getChildStreamList() ,public UniConstraintStream<Result_> groupBy(QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_>) ,public BiConstraintStream<ResultA_,ResultB_> groupBy(QuadConstraintCollector<A,B,C,D,ResultContainerA_,ResultA_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>) ,public TriConstraintStream<ResultA_,ResultB_,ResultC_> groupBy(QuadConstraintCollector<A,B,C,D,ResultContainerA_,ResultA_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_> groupBy(QuadConstraintCollector<A,B,C,D,ResultContainerA_,ResultA_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>, QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_>) ,public UniConstraintStream<GroupKey_> groupBy(QuadFunction<A,B,C,D,GroupKey_>) ,public TriConstraintStream<GroupKey_,ResultB_,ResultC_> groupBy(QuadFunction<A,B,C,D,GroupKey_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_> groupBy(QuadFunction<A,B,C,D,GroupKey_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>, QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_>) ,public BiConstraintStream<GroupKey_,Result_> groupBy(QuadFunction<A,B,C,D,GroupKey_>, QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_>) ,public BiConstraintStream<GroupKeyA_,GroupKeyB_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>, QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadFunction<A,B,C,D,GroupKeyC_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadFunction<A,B,C,D,GroupKeyC_>, QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadFunction<A,B,C,D,GroupKeyC_>, QuadFunction<A,B,C,D,GroupKeyD_>) ,public final transient QuadConstraintStream<A,B,C,D> ifExists(Class<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifExists(UniConstraintStream<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifExistsIncludingNullVars(Class<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifNotExists(Class<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifNotExists(UniConstraintStream<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifNotExistsIncludingNullVars(Class<E>, PentaJoiner<A,B,C,D,E>[]) ,public QuadConstraintBuilder<A,B,C,D,Score_> innerImpact(Score_, ToIntQuadFunction<A,B,C,D>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public QuadConstraintBuilder<A,B,C,D,Score_> innerImpact(Score_, ToLongQuadFunction<A,B,C,D>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public QuadConstraintBuilder<A,B,C,D,Score_> innerImpact(Score_, QuadFunction<A,B,C,D,java.math.BigDecimal>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public UniConstraintStream<ResultA_> map(QuadFunction<A,B,C,D,ResultA_>) ,public Stream_ shareAndAddChild(Stream_) <variables>protected final List<BavetAbstractQuadConstraintStream<Solution_,A,B,C,D>> childStreamList
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/quad/BavetGroupQuadConstraintStream.java
|
BavetGroupQuadConstraintStream
|
toString
|
class BavetGroupQuadConstraintStream<Solution_, A, B, C, D>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
private final BavetAbstractConstraintStream<Solution_> parent;
public BavetGroupQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractConstraintStream<Solution_> parent) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
// Do nothing. BavetGroupBridgeUniConstraintStream, etc build everything.
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
// TODO
@Override
public String toString() {<FILL_FUNCTION_BODY>}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
return "Group() with " + childStreamList.size() + " children";
| 371
| 22
| 393
|
<methods>public void <init>(BavetConstraintFactory<Solution_>, org.optaplanner.constraint.streams.common.RetrievalSemantics) ,public BavetAbstractQuadConstraintStream<Solution_,A,B,C,D> filter(QuadPredicate<A,B,C,D>) ,public QuadConstraintStream<A,B,C,ResultD_> flattenLast(Function<D,Iterable<ResultD_>>) ,public List<BavetAbstractQuadConstraintStream<Solution_,A,B,C,D>> getChildStreamList() ,public UniConstraintStream<Result_> groupBy(QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_>) ,public BiConstraintStream<ResultA_,ResultB_> groupBy(QuadConstraintCollector<A,B,C,D,ResultContainerA_,ResultA_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>) ,public TriConstraintStream<ResultA_,ResultB_,ResultC_> groupBy(QuadConstraintCollector<A,B,C,D,ResultContainerA_,ResultA_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_> groupBy(QuadConstraintCollector<A,B,C,D,ResultContainerA_,ResultA_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>, QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_>) ,public UniConstraintStream<GroupKey_> groupBy(QuadFunction<A,B,C,D,GroupKey_>) ,public TriConstraintStream<GroupKey_,ResultB_,ResultC_> groupBy(QuadFunction<A,B,C,D,GroupKey_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_> groupBy(QuadFunction<A,B,C,D,GroupKey_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>, QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_>) ,public BiConstraintStream<GroupKey_,Result_> groupBy(QuadFunction<A,B,C,D,GroupKey_>, QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_>) ,public BiConstraintStream<GroupKeyA_,GroupKeyB_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>, QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadFunction<A,B,C,D,GroupKeyC_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadFunction<A,B,C,D,GroupKeyC_>, QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadFunction<A,B,C,D,GroupKeyC_>, QuadFunction<A,B,C,D,GroupKeyD_>) ,public final transient QuadConstraintStream<A,B,C,D> ifExists(Class<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifExists(UniConstraintStream<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifExistsIncludingNullVars(Class<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifNotExists(Class<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifNotExists(UniConstraintStream<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifNotExistsIncludingNullVars(Class<E>, PentaJoiner<A,B,C,D,E>[]) ,public QuadConstraintBuilder<A,B,C,D,Score_> innerImpact(Score_, ToIntQuadFunction<A,B,C,D>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public QuadConstraintBuilder<A,B,C,D,Score_> innerImpact(Score_, ToLongQuadFunction<A,B,C,D>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public QuadConstraintBuilder<A,B,C,D,Score_> innerImpact(Score_, QuadFunction<A,B,C,D,java.math.BigDecimal>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public UniConstraintStream<ResultA_> map(QuadFunction<A,B,C,D,ResultA_>) ,public Stream_ shareAndAddChild(Stream_) <variables>protected final List<BavetAbstractQuadConstraintStream<Solution_,A,B,C,D>> childStreamList
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/quad/BavetIfExistsQuadConstraintStream.java
|
BavetIfExistsQuadConstraintStream
|
buildNode
|
class BavetIfExistsQuadConstraintStream<Solution_, A, B, C, D, E>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
private final BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parentABCD;
private final BavetIfExistsBridgeUniConstraintStream<Solution_, E> parentBridgeE;
private final boolean shouldExist;
private final DefaultPentaJoiner<A, B, C, D, E> joiner;
private final PentaPredicate<A, B, C, D, E> filtering;
public BavetIfExistsQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parentABCD,
BavetIfExistsBridgeUniConstraintStream<Solution_, E> parentBridgeE,
boolean shouldExist,
DefaultPentaJoiner<A, B, C, D, E> joiner, PentaPredicate<A, B, C, D, E> filtering) {
super(constraintFactory, parentABCD.getRetrievalSemantics());
this.parentABCD = parentABCD;
this.parentBridgeE = parentBridgeE;
this.shouldExist = shouldExist;
this.joiner = joiner;
this.filtering = filtering;
}
@Override
public boolean guaranteesDistinct() {
return parentABCD.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parentABCD.collectActiveConstraintStreams(constraintStreamSet);
parentBridgeE.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parentABCD.getTupleSource();
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {<FILL_FUNCTION_BODY>}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
// TODO
@Override
public String toString() {
return "IfExists() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
TupleLifecycle<QuadTuple<A, B, C, D>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
IndexerFactory indexerFactory = new IndexerFactory(joiner);
AbstractIfExistsNode<QuadTuple<A, B, C, D>, E> node = indexerFactory.hasJoiners()
? (filtering == null ? new IndexedIfExistsQuadNode<>(shouldExist,
JoinerUtils.combineLeftMappings(joiner), JoinerUtils.combineRightMappings(joiner),
buildHelper.reserveTupleStoreIndex(parentABCD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentABCD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeE.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeE.getTupleSource()),
downstream, indexerFactory.buildIndexer(true), indexerFactory.buildIndexer(false))
: new IndexedIfExistsQuadNode<>(shouldExist,
JoinerUtils.combineLeftMappings(joiner), JoinerUtils.combineRightMappings(joiner),
buildHelper.reserveTupleStoreIndex(parentABCD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentABCD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentABCD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeE.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeE.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeE.getTupleSource()),
downstream, indexerFactory.buildIndexer(true), indexerFactory.buildIndexer(false),
filtering))
: (filtering == null ? new UnindexedIfExistsQuadNode<>(shouldExist,
buildHelper.reserveTupleStoreIndex(parentABCD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeE.getTupleSource()), downstream)
: new UnindexedIfExistsQuadNode<>(shouldExist,
buildHelper.reserveTupleStoreIndex(parentABCD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentABCD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeE.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeE.getTupleSource()),
downstream, filtering));
buildHelper.addNode(node, this, parentBridgeE);
| 663
| 658
| 1,321
|
<methods>public void <init>(BavetConstraintFactory<Solution_>, org.optaplanner.constraint.streams.common.RetrievalSemantics) ,public BavetAbstractQuadConstraintStream<Solution_,A,B,C,D> filter(QuadPredicate<A,B,C,D>) ,public QuadConstraintStream<A,B,C,ResultD_> flattenLast(Function<D,Iterable<ResultD_>>) ,public List<BavetAbstractQuadConstraintStream<Solution_,A,B,C,D>> getChildStreamList() ,public UniConstraintStream<Result_> groupBy(QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_>) ,public BiConstraintStream<ResultA_,ResultB_> groupBy(QuadConstraintCollector<A,B,C,D,ResultContainerA_,ResultA_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>) ,public TriConstraintStream<ResultA_,ResultB_,ResultC_> groupBy(QuadConstraintCollector<A,B,C,D,ResultContainerA_,ResultA_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_> groupBy(QuadConstraintCollector<A,B,C,D,ResultContainerA_,ResultA_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>, QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_>) ,public UniConstraintStream<GroupKey_> groupBy(QuadFunction<A,B,C,D,GroupKey_>) ,public TriConstraintStream<GroupKey_,ResultB_,ResultC_> groupBy(QuadFunction<A,B,C,D,GroupKey_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_> groupBy(QuadFunction<A,B,C,D,GroupKey_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>, QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_>) ,public BiConstraintStream<GroupKey_,Result_> groupBy(QuadFunction<A,B,C,D,GroupKey_>, QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_>) ,public BiConstraintStream<GroupKeyA_,GroupKeyB_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>, QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadFunction<A,B,C,D,GroupKeyC_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadFunction<A,B,C,D,GroupKeyC_>, QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadFunction<A,B,C,D,GroupKeyC_>, QuadFunction<A,B,C,D,GroupKeyD_>) ,public final transient QuadConstraintStream<A,B,C,D> ifExists(Class<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifExists(UniConstraintStream<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifExistsIncludingNullVars(Class<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifNotExists(Class<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifNotExists(UniConstraintStream<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifNotExistsIncludingNullVars(Class<E>, PentaJoiner<A,B,C,D,E>[]) ,public QuadConstraintBuilder<A,B,C,D,Score_> innerImpact(Score_, ToIntQuadFunction<A,B,C,D>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public QuadConstraintBuilder<A,B,C,D,Score_> innerImpact(Score_, ToLongQuadFunction<A,B,C,D>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public QuadConstraintBuilder<A,B,C,D,Score_> innerImpact(Score_, QuadFunction<A,B,C,D,java.math.BigDecimal>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public UniConstraintStream<ResultA_> map(QuadFunction<A,B,C,D,ResultA_>) ,public Stream_ shareAndAddChild(Stream_) <variables>protected final List<BavetAbstractQuadConstraintStream<Solution_,A,B,C,D>> childStreamList
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/quad/BavetJoinQuadConstraintStream.java
|
BavetJoinQuadConstraintStream
|
equals
|
class BavetJoinQuadConstraintStream<Solution_, A, B, C, D>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D>
implements BavetJoinConstraintStream<Solution_> {
private final BavetJoinBridgeTriConstraintStream<Solution_, A, B, C> leftParent;
private final BavetJoinBridgeUniConstraintStream<Solution_, D> rightParent;
private final DefaultQuadJoiner<A, B, C, D> joiner;
private final QuadPredicate<A, B, C, D> filtering;
public BavetJoinQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetJoinBridgeTriConstraintStream<Solution_, A, B, C> leftParent,
BavetJoinBridgeUniConstraintStream<Solution_, D> rightParent,
DefaultQuadJoiner<A, B, C, D> joiner, QuadPredicate<A, B, C, D> filtering) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.joiner = joiner;
this.filtering = filtering;
}
@Override
public boolean guaranteesDistinct() {
return leftParent.guaranteesDistinct() && rightParent.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
leftParent.collectActiveConstraintStreams(constraintStreamSet);
rightParent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
int outputStoreSize = buildHelper.extractTupleStoreSize(this);
TupleLifecycle<QuadTuple<A, B, C, D>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
IndexerFactory indexerFactory = new IndexerFactory(joiner);
AbstractJoinNode<TriTuple<A, B, C>, D, QuadTuple<A, B, C, D>, QuadTupleImpl<A, B, C, D>> node =
indexerFactory.hasJoiners()
? new IndexedJoinQuadNode<>(
JoinerUtils.combineLeftMappings(joiner), JoinerUtils.combineRightMappings(joiner),
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
downstream, filtering, outputStoreSize + 2,
outputStoreSize, outputStoreSize + 1,
indexerFactory.buildIndexer(true), indexerFactory.buildIndexer(false))
: new UnindexedJoinQuadNode<>(
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
downstream, filtering, outputStoreSize + 2,
outputStoreSize, outputStoreSize + 1);
buildHelper.addNode(node, leftParent, rightParent);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object o) {<FILL_FUNCTION_BODY>}
@Override
public int hashCode() {
return Objects.hash(leftParent.getParent(), rightParent.getParent(), joiner, filtering);
}
@Override
public String toString() {
return "QuadJoin() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
BavetJoinQuadConstraintStream<?, ?, ?, ?, ?> other = (BavetJoinQuadConstraintStream<?, ?, ?, ?, ?>) o;
/*
* Bridge streams do not implement equality because their equals() would have to point back to this stream,
* resulting in StackOverflowError.
* Therefore we need to check bridge parents to see where this join node comes from.
*/
return Objects.equals(leftParent.getParent(), other.leftParent.getParent())
&& Objects.equals(rightParent.getParent(), other.rightParent.getParent())
&& Objects.equals(joiner, other.joiner)
&& Objects.equals(filtering, other.filtering);
| 1,119
| 224
| 1,343
|
<methods>public void <init>(BavetConstraintFactory<Solution_>, org.optaplanner.constraint.streams.common.RetrievalSemantics) ,public BavetAbstractQuadConstraintStream<Solution_,A,B,C,D> filter(QuadPredicate<A,B,C,D>) ,public QuadConstraintStream<A,B,C,ResultD_> flattenLast(Function<D,Iterable<ResultD_>>) ,public List<BavetAbstractQuadConstraintStream<Solution_,A,B,C,D>> getChildStreamList() ,public UniConstraintStream<Result_> groupBy(QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_>) ,public BiConstraintStream<ResultA_,ResultB_> groupBy(QuadConstraintCollector<A,B,C,D,ResultContainerA_,ResultA_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>) ,public TriConstraintStream<ResultA_,ResultB_,ResultC_> groupBy(QuadConstraintCollector<A,B,C,D,ResultContainerA_,ResultA_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_> groupBy(QuadConstraintCollector<A,B,C,D,ResultContainerA_,ResultA_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>, QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_>) ,public UniConstraintStream<GroupKey_> groupBy(QuadFunction<A,B,C,D,GroupKey_>) ,public TriConstraintStream<GroupKey_,ResultB_,ResultC_> groupBy(QuadFunction<A,B,C,D,GroupKey_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_> groupBy(QuadFunction<A,B,C,D,GroupKey_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>, QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_>) ,public BiConstraintStream<GroupKey_,Result_> groupBy(QuadFunction<A,B,C,D,GroupKey_>, QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_>) ,public BiConstraintStream<GroupKeyA_,GroupKeyB_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>, QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadFunction<A,B,C,D,GroupKeyC_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadFunction<A,B,C,D,GroupKeyC_>, QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadFunction<A,B,C,D,GroupKeyC_>, QuadFunction<A,B,C,D,GroupKeyD_>) ,public final transient QuadConstraintStream<A,B,C,D> ifExists(Class<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifExists(UniConstraintStream<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifExistsIncludingNullVars(Class<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifNotExists(Class<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifNotExists(UniConstraintStream<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifNotExistsIncludingNullVars(Class<E>, PentaJoiner<A,B,C,D,E>[]) ,public QuadConstraintBuilder<A,B,C,D,Score_> innerImpact(Score_, ToIntQuadFunction<A,B,C,D>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public QuadConstraintBuilder<A,B,C,D,Score_> innerImpact(Score_, ToLongQuadFunction<A,B,C,D>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public QuadConstraintBuilder<A,B,C,D,Score_> innerImpact(Score_, QuadFunction<A,B,C,D,java.math.BigDecimal>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public UniConstraintStream<ResultA_> map(QuadFunction<A,B,C,D,ResultA_>) ,public Stream_ shareAndAddChild(Stream_) <variables>protected final List<BavetAbstractQuadConstraintStream<Solution_,A,B,C,D>> childStreamList
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/quad/BavetMapBridgeQuadConstraintStream.java
|
BavetMapBridgeQuadConstraintStream
|
buildNode
|
class BavetMapBridgeQuadConstraintStream<Solution_, A, B, C, D, NewA>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
private final BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent;
private final QuadFunction<A, B, C, D, NewA> mappingFunction;
private BavetMapUniConstraintStream<Solution_, NewA> mapStream;
public BavetMapBridgeQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent, QuadFunction<A, B, C, D, NewA> mappingFunction) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
this.mappingFunction = mappingFunction;
}
@Override
public boolean guaranteesDistinct() {
return false;
}
public void setMapStream(BavetMapUniConstraintStream<Solution_, NewA> mapStream) {
this.mapStream = mapStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parent.getTupleSource();
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {<FILL_FUNCTION_BODY>}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
// TODO
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
if (!childStreamList.isEmpty()) {
throw new IllegalStateException("Impossible state: the stream (" + this
+ ") has a non-empty childStreamList (" + childStreamList + ") but it's a flattenLast bridge.");
}
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(mapStream);
AbstractMapNode<QuadTuple<A, B, C, D>, NewA> node = new MapQuadNode<>(inputStoreIndex, mappingFunction,
buildHelper.getAggregatedTupleLifecycle(mapStream.getChildStreamList()), outputStoreSize);
buildHelper.addNode(node, this);
| 509
| 185
| 694
|
<methods>public void <init>(BavetConstraintFactory<Solution_>, org.optaplanner.constraint.streams.common.RetrievalSemantics) ,public BavetAbstractQuadConstraintStream<Solution_,A,B,C,D> filter(QuadPredicate<A,B,C,D>) ,public QuadConstraintStream<A,B,C,ResultD_> flattenLast(Function<D,Iterable<ResultD_>>) ,public List<BavetAbstractQuadConstraintStream<Solution_,A,B,C,D>> getChildStreamList() ,public UniConstraintStream<Result_> groupBy(QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_>) ,public BiConstraintStream<ResultA_,ResultB_> groupBy(QuadConstraintCollector<A,B,C,D,ResultContainerA_,ResultA_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>) ,public TriConstraintStream<ResultA_,ResultB_,ResultC_> groupBy(QuadConstraintCollector<A,B,C,D,ResultContainerA_,ResultA_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_> groupBy(QuadConstraintCollector<A,B,C,D,ResultContainerA_,ResultA_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>, QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_>) ,public UniConstraintStream<GroupKey_> groupBy(QuadFunction<A,B,C,D,GroupKey_>) ,public TriConstraintStream<GroupKey_,ResultB_,ResultC_> groupBy(QuadFunction<A,B,C,D,GroupKey_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_> groupBy(QuadFunction<A,B,C,D,GroupKey_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>, QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_>) ,public BiConstraintStream<GroupKey_,Result_> groupBy(QuadFunction<A,B,C,D,GroupKey_>, QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_>) ,public BiConstraintStream<GroupKeyA_,GroupKeyB_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>, QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadFunction<A,B,C,D,GroupKeyC_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadFunction<A,B,C,D,GroupKeyC_>, QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadFunction<A,B,C,D,GroupKeyC_>, QuadFunction<A,B,C,D,GroupKeyD_>) ,public final transient QuadConstraintStream<A,B,C,D> ifExists(Class<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifExists(UniConstraintStream<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifExistsIncludingNullVars(Class<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifNotExists(Class<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifNotExists(UniConstraintStream<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifNotExistsIncludingNullVars(Class<E>, PentaJoiner<A,B,C,D,E>[]) ,public QuadConstraintBuilder<A,B,C,D,Score_> innerImpact(Score_, ToIntQuadFunction<A,B,C,D>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public QuadConstraintBuilder<A,B,C,D,Score_> innerImpact(Score_, ToLongQuadFunction<A,B,C,D>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public QuadConstraintBuilder<A,B,C,D,Score_> innerImpact(Score_, QuadFunction<A,B,C,D,java.math.BigDecimal>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public UniConstraintStream<ResultA_> map(QuadFunction<A,B,C,D,ResultA_>) ,public Stream_ shareAndAddChild(Stream_) <variables>protected final List<BavetAbstractQuadConstraintStream<Solution_,A,B,C,D>> childStreamList
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/quad/BavetUniGroupBridgeQuadConstraintStream.java
|
BavetUniGroupBridgeQuadConstraintStream
|
buildNode
|
class BavetUniGroupBridgeQuadConstraintStream<Solution_, A, B, C, D, NewA>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
protected final BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent;
protected BavetGroupUniConstraintStream<Solution_, NewA> groupStream;
private final GroupNodeConstructor<UniTuple<NewA>> nodeConstructor;
public BavetUniGroupBridgeQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent,
GroupNodeConstructor<UniTuple<NewA>> nodeConstructor) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
this.nodeConstructor = nodeConstructor;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
public void setGroupStream(BavetGroupUniConstraintStream<Solution_, NewA> groupStream) {
this.groupStream = groupStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {<FILL_FUNCTION_BODY>}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parent.getTupleSource();
}
}
|
List<? extends ConstraintStream> groupStreamChildList = groupStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), groupStream, groupStreamChildList, this, childStreamList,
constraintFactory.getEnvironmentMode());
| 458
| 66
| 524
|
<methods>public void <init>(BavetConstraintFactory<Solution_>, org.optaplanner.constraint.streams.common.RetrievalSemantics) ,public BavetAbstractQuadConstraintStream<Solution_,A,B,C,D> filter(QuadPredicate<A,B,C,D>) ,public QuadConstraintStream<A,B,C,ResultD_> flattenLast(Function<D,Iterable<ResultD_>>) ,public List<BavetAbstractQuadConstraintStream<Solution_,A,B,C,D>> getChildStreamList() ,public UniConstraintStream<Result_> groupBy(QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_>) ,public BiConstraintStream<ResultA_,ResultB_> groupBy(QuadConstraintCollector<A,B,C,D,ResultContainerA_,ResultA_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>) ,public TriConstraintStream<ResultA_,ResultB_,ResultC_> groupBy(QuadConstraintCollector<A,B,C,D,ResultContainerA_,ResultA_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_> groupBy(QuadConstraintCollector<A,B,C,D,ResultContainerA_,ResultA_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>, QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_>) ,public UniConstraintStream<GroupKey_> groupBy(QuadFunction<A,B,C,D,GroupKey_>) ,public TriConstraintStream<GroupKey_,ResultB_,ResultC_> groupBy(QuadFunction<A,B,C,D,GroupKey_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_> groupBy(QuadFunction<A,B,C,D,GroupKey_>, QuadConstraintCollector<A,B,C,D,ResultContainerB_,ResultB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>, QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_>) ,public BiConstraintStream<GroupKey_,Result_> groupBy(QuadFunction<A,B,C,D,GroupKey_>, QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_>) ,public BiConstraintStream<GroupKeyA_,GroupKeyB_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadConstraintCollector<A,B,C,D,ResultContainer_,Result_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadConstraintCollector<A,B,C,D,ResultContainerC_,ResultC_>, QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadFunction<A,B,C,D,GroupKeyC_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadFunction<A,B,C,D,GroupKeyC_>, QuadConstraintCollector<A,B,C,D,ResultContainerD_,ResultD_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> groupBy(QuadFunction<A,B,C,D,GroupKeyA_>, QuadFunction<A,B,C,D,GroupKeyB_>, QuadFunction<A,B,C,D,GroupKeyC_>, QuadFunction<A,B,C,D,GroupKeyD_>) ,public final transient QuadConstraintStream<A,B,C,D> ifExists(Class<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifExists(UniConstraintStream<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifExistsIncludingNullVars(Class<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifNotExists(Class<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifNotExists(UniConstraintStream<E>, PentaJoiner<A,B,C,D,E>[]) ,public final transient QuadConstraintStream<A,B,C,D> ifNotExistsIncludingNullVars(Class<E>, PentaJoiner<A,B,C,D,E>[]) ,public QuadConstraintBuilder<A,B,C,D,Score_> innerImpact(Score_, ToIntQuadFunction<A,B,C,D>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public QuadConstraintBuilder<A,B,C,D,Score_> innerImpact(Score_, ToLongQuadFunction<A,B,C,D>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public QuadConstraintBuilder<A,B,C,D,Score_> innerImpact(Score_, QuadFunction<A,B,C,D,java.math.BigDecimal>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public UniConstraintStream<ResultA_> map(QuadFunction<A,B,C,D,ResultA_>) ,public Stream_ shareAndAddChild(Stream_) <variables>protected final List<BavetAbstractQuadConstraintStream<Solution_,A,B,C,D>> childStreamList
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/quad/Group2Mapping0CollectorQuadNode.java
|
Group2Mapping0CollectorQuadNode
|
createGroupKey
|
class Group2Mapping0CollectorQuadNode<OldA, OldB, OldC, OldD, A, B>
extends AbstractGroupQuadNode<OldA, OldB, OldC, OldD, BiTuple<A, B>, BiTupleImpl<A, B>, Pair<A, B>, Void, Void> {
private final int outputStoreSize;
public Group2Mapping0CollectorQuadNode(QuadFunction<OldA, OldB, OldC, OldD, A> groupKeyMappingA,
QuadFunction<OldA, OldB, OldC, OldD, B> groupKeyMappingB, int groupStoreIndex,
TupleLifecycle<BiTuple<A, B>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex, tuple -> createGroupKey(groupKeyMappingA, groupKeyMappingB, tuple), nextNodesTupleLifecycle,
environmentMode);
this.outputStoreSize = outputStoreSize;
}
static <A, B, OldA, OldB, OldC, OldD> Pair<A, B> createGroupKey(QuadFunction<OldA, OldB, OldC, OldD, A> groupKeyMappingA,
QuadFunction<OldA, OldB, OldC, OldD, B> groupKeyMappingB, QuadTuple<OldA, OldB, OldC, OldD> tuple) {<FILL_FUNCTION_BODY>}
@Override
protected BiTupleImpl<A, B> createOutTuple(Pair<A, B> groupKey) {
return new BiTupleImpl<>(groupKey.getKey(), groupKey.getValue(), outputStoreSize);
}
@Override
protected void updateOutTupleToResult(BiTupleImpl<A, B> outTuple, Void unused) {
throw new IllegalStateException("Impossible state: collector is null.");
}
}
|
OldA oldA = tuple.getFactA();
OldB oldB = tuple.getFactB();
OldC oldC = tuple.getFactC();
OldD oldD = tuple.getFactD();
A a = groupKeyMappingA.apply(oldA, oldB, oldC, oldD);
B b = groupKeyMappingB.apply(oldA, oldB, oldC, oldD);
return Pair.of(a, b);
| 481
| 115
| 596
|
<methods><variables>private final non-sealed PentaFunction<java.lang.Void,OldA,OldB,OldC,OldD,java.lang.Runnable> accumulator
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/quad/Group3Mapping0CollectorQuadNode.java
|
Group3Mapping0CollectorQuadNode
|
createGroupKey
|
class Group3Mapping0CollectorQuadNode<OldA, OldB, OldC, OldD, A, B, C>
extends
AbstractGroupQuadNode<OldA, OldB, OldC, OldD, TriTuple<A, B, C>, TriTupleImpl<A, B, C>, Triple<A, B, C>, Void, Void> {
private final int outputStoreSize;
public Group3Mapping0CollectorQuadNode(QuadFunction<OldA, OldB, OldC, OldD, A> groupKeyMappingA,
QuadFunction<OldA, OldB, OldC, OldD, B> groupKeyMappingB, QuadFunction<OldA, OldB, OldC, OldD, C> groupKeyMappingC,
int groupStoreIndex, TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle, int outputStoreSize,
EnvironmentMode environmentMode) {
super(groupStoreIndex, tuple -> createGroupKey(groupKeyMappingA, groupKeyMappingB, groupKeyMappingC, tuple),
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
static <A, B, C, OldA, OldB, OldC, OldD> Triple<A, B, C> createGroupKey(
QuadFunction<OldA, OldB, OldC, OldD, A> groupKeyMappingA,
QuadFunction<OldA, OldB, OldC, OldD, B> groupKeyMappingB,
QuadFunction<OldA, OldB, OldC, OldD, C> groupKeyMappingC,
QuadTuple<OldA, OldB, OldC, OldD> tuple) {<FILL_FUNCTION_BODY>}
@Override
protected TriTupleImpl<A, B, C> createOutTuple(Triple<A, B, C> groupKey) {
return new TriTupleImpl<>(groupKey.getA(), groupKey.getB(), groupKey.getC(), outputStoreSize);
}
@Override
protected void updateOutTupleToResult(TriTupleImpl<A, B, C> outTuple, Void unused) {
throw new IllegalStateException("Impossible state: collector is null.");
}
}
|
OldA oldA = tuple.getFactA();
OldB oldB = tuple.getFactB();
OldC oldC = tuple.getFactC();
OldD oldD = tuple.getFactD();
A a = groupKeyMappingA.apply(oldA, oldB, oldC, oldD);
B b = groupKeyMappingB.apply(oldA, oldB, oldC, oldD);
C c = groupKeyMappingC.apply(oldA, oldB, oldC, oldD);
return Triple.of(a, b, c);
| 570
| 141
| 711
|
<methods><variables>private final non-sealed PentaFunction<java.lang.Void,OldA,OldB,OldC,OldD,java.lang.Runnable> accumulator
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/quad/Group4Mapping0CollectorQuadNode.java
|
Group4Mapping0CollectorQuadNode
|
createGroupKey
|
class Group4Mapping0CollectorQuadNode<OldA, OldB, OldC, OldD, A, B, C, D>
extends
AbstractGroupQuadNode<OldA, OldB, OldC, OldD, QuadTuple<A, B, C, D>, QuadTupleImpl<A, B, C, D>, Quadruple<A, B, C, D>, Void, Void> {
private final int outputStoreSize;
public Group4Mapping0CollectorQuadNode(QuadFunction<OldA, OldB, OldC, OldD, A> groupKeyMappingA,
QuadFunction<OldA, OldB, OldC, OldD, B> groupKeyMappingB, QuadFunction<OldA, OldB, OldC, OldD, C> groupKeyMappingC,
QuadFunction<OldA, OldB, OldC, OldD, D> groupKeyMappingD, int groupStoreIndex,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle, int outputStoreSize,
EnvironmentMode environmentMode) {
super(groupStoreIndex,
tuple -> createGroupKey(groupKeyMappingA, groupKeyMappingB, groupKeyMappingC, groupKeyMappingD, tuple),
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
private static <A, B, C, D, OldA, OldB, OldC, OldD> Quadruple<A, B, C, D> createGroupKey(
QuadFunction<OldA, OldB, OldC, OldD, A> groupKeyMappingA,
QuadFunction<OldA, OldB, OldC, OldD, B> groupKeyMappingB,
QuadFunction<OldA, OldB, OldC, OldD, C> groupKeyMappingC,
QuadFunction<OldA, OldB, OldC, OldD, D> groupKeyMappingD,
QuadTuple<OldA, OldB, OldC, OldD> tuple) {<FILL_FUNCTION_BODY>}
@Override
protected QuadTupleImpl<A, B, C, D> createOutTuple(Quadruple<A, B, C, D> groupKey) {
return new QuadTupleImpl<>(groupKey.getA(), groupKey.getB(), groupKey.getC(), groupKey.getD(), outputStoreSize);
}
@Override
protected void updateOutTupleToResult(QuadTupleImpl<A, B, C, D> outTuple, Void unused) {
throw new IllegalStateException("Impossible state: collector is null.");
}
}
|
OldA oldA = tuple.getFactA();
OldB oldB = tuple.getFactB();
OldC oldC = tuple.getFactC();
OldD oldD = tuple.getFactD();
A a = groupKeyMappingA.apply(oldA, oldB, oldC, oldD);
B b = groupKeyMappingB.apply(oldA, oldB, oldC, oldD);
C c = groupKeyMappingC.apply(oldA, oldB, oldC, oldD);
D d = groupKeyMappingD.apply(oldA, oldB, oldC, oldD);
return Quadruple.of(a, b, c, d);
| 666
| 169
| 835
|
<methods><variables>private final non-sealed PentaFunction<java.lang.Void,OldA,OldB,OldC,OldD,java.lang.Runnable> accumulator
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/quad/IndexedJoinQuadNode.java
|
IndexedJoinQuadNode
|
setOutTupleLeftFacts
|
class IndexedJoinQuadNode<A, B, C, D>
extends AbstractIndexedJoinNode<TriTuple<A, B, C>, D, QuadTuple<A, B, C, D>, QuadTupleImpl<A, B, C, D>> {
private final TriFunction<A, B, C, IndexProperties> mappingABC;
private final QuadPredicate<A, B, C, D> filtering;
private final int outputStoreSize;
public IndexedJoinQuadNode(TriFunction<A, B, C, IndexProperties> mappingABC, Function<D, IndexProperties> mappingD,
int inputStoreIndexABC, int inputStoreIndexEntryABC, int inputStoreIndexOutTupleListABC,
int inputStoreIndexD, int inputStoreIndexEntryD, int inputStoreIndexOutTupleListD,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle, QuadPredicate<A, B, C, D> filtering,
int outputStoreSize,
int outputStoreIndexOutEntryABC, int outputStoreIndexOutEntryD,
Indexer<TriTuple<A, B, C>> indexerABC,
Indexer<UniTuple<D>> indexerD) {
super(mappingD,
inputStoreIndexABC, inputStoreIndexEntryABC, inputStoreIndexOutTupleListABC,
inputStoreIndexD, inputStoreIndexEntryD, inputStoreIndexOutTupleListD,
nextNodesTupleLifecycle, filtering != null,
outputStoreIndexOutEntryABC, outputStoreIndexOutEntryD,
indexerABC, indexerD);
this.mappingABC = mappingABC;
this.filtering = filtering;
this.outputStoreSize = outputStoreSize;
}
@Override
protected IndexProperties createIndexPropertiesLeft(TriTuple<A, B, C> leftTuple) {
return mappingABC.apply(leftTuple.getFactA(), leftTuple.getFactB(), leftTuple.getFactC());
}
@Override
protected QuadTupleImpl<A, B, C, D> createOutTuple(TriTuple<A, B, C> leftTuple, UniTuple<D> rightTuple) {
return new QuadTupleImpl<>(leftTuple.getFactA(), leftTuple.getFactB(), leftTuple.getFactC(), rightTuple.getFactA(),
outputStoreSize);
}
@Override
protected void setOutTupleLeftFacts(QuadTupleImpl<A, B, C, D> outTuple, TriTuple<A, B, C> leftTuple) {<FILL_FUNCTION_BODY>}
@Override
protected void setOutTupleRightFact(QuadTupleImpl<A, B, C, D> outTuple, UniTuple<D> rightTuple) {
outTuple.factD = rightTuple.getFactA();
}
@Override
protected boolean testFiltering(TriTuple<A, B, C> leftTuple, UniTuple<D> rightTuple) {
return filtering.test(leftTuple.getFactA(), leftTuple.getFactB(), leftTuple.getFactC(), rightTuple.getFactA());
}
}
|
outTuple.factA = leftTuple.getFactA();
outTuple.factB = leftTuple.getFactB();
outTuple.factC = leftTuple.getFactC();
| 833
| 54
| 887
|
<methods>public final void insertLeft(TriTuple<A,B,C>) ,public final void insertRight(UniTuple<D>) ,public final void retractLeft(TriTuple<A,B,C>) ,public final void retractRight(UniTuple<D>) ,public final void updateLeft(TriTuple<A,B,C>) ,public final void updateRight(UniTuple<D>) <variables>private final non-sealed Indexer<TriTuple<A,B,C>> indexerLeft,private final non-sealed Indexer<UniTuple<D>> indexerRight,private final non-sealed int inputStoreIndexLeftEntry,private final non-sealed int inputStoreIndexLeftProperties,private final non-sealed int inputStoreIndexRightEntry,private final non-sealed int inputStoreIndexRightProperties,private final non-sealed Function<D,org.optaplanner.constraint.streams.bavet.common.index.IndexProperties> mappingRight
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/quad/QuadScorer.java
|
QuadScorer
|
impact
|
class QuadScorer<A, B, C, D> extends AbstractScorer<QuadTuple<A, B, C, D>> {
private final QuadFunction<A, B, C, D, UndoScoreImpacter> scoreImpacter;
public QuadScorer(String constraintPackage, String constraintName, Score<?> constraintWeight,
QuadFunction<A, B, C, D, UndoScoreImpacter> scoreImpacter, int inputStoreIndex) {
super(constraintPackage, constraintName, constraintWeight, inputStoreIndex);
this.scoreImpacter = scoreImpacter;
}
@Override
protected UndoScoreImpacter impact(QuadTuple<A, B, C, D> tuple) {<FILL_FUNCTION_BODY>}
}
|
try {
return scoreImpacter.apply(tuple.getFactA(), tuple.getFactB(), tuple.getFactC(), tuple.getFactD());
} catch (Exception e) {
throw createExceptionOnImpact(tuple, e);
}
| 200
| 69
| 269
|
<methods>public final void insert(QuadTuple<A,B,C,D>) ,public final void retract(QuadTuple<A,B,C,D>) ,public final java.lang.String toString() ,public final void update(QuadTuple<A,B,C,D>) <variables>private final non-sealed java.lang.String constraintId,private final non-sealed Score<?> constraintWeight,private final non-sealed int inputStoreIndex
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/quad/UnindexedJoinQuadNode.java
|
UnindexedJoinQuadNode
|
setOutTupleLeftFacts
|
class UnindexedJoinQuadNode<A, B, C, D>
extends AbstractUnindexedJoinNode<TriTuple<A, B, C>, D, QuadTuple<A, B, C, D>, QuadTupleImpl<A, B, C, D>> {
private final QuadPredicate<A, B, C, D> filtering;
private final int outputStoreSize;
public UnindexedJoinQuadNode(
int inputStoreIndexLeftEntry, int inputStoreIndexLeftOutTupleList,
int inputStoreIndexRightEntry, int inputStoreIndexRightOutTupleList,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle, QuadPredicate<A, B, C, D> filtering,
int outputStoreSize,
int outputStoreIndexLeftOutEntry, int outputStoreIndexRightOutEntry) {
super(inputStoreIndexLeftEntry, inputStoreIndexLeftOutTupleList,
inputStoreIndexRightEntry, inputStoreIndexRightOutTupleList,
nextNodesTupleLifecycle, filtering != null,
outputStoreIndexLeftOutEntry, outputStoreIndexRightOutEntry);
this.filtering = filtering;
this.outputStoreSize = outputStoreSize;
}
@Override
protected QuadTupleImpl<A, B, C, D> createOutTuple(TriTuple<A, B, C> leftTuple, UniTuple<D> rightTuple) {
return new QuadTupleImpl<>(leftTuple.getFactA(), leftTuple.getFactB(), leftTuple.getFactC(), rightTuple.getFactA(),
outputStoreSize);
}
@Override
protected void setOutTupleLeftFacts(QuadTupleImpl<A, B, C, D> outTuple, TriTuple<A, B, C> leftTuple) {<FILL_FUNCTION_BODY>}
@Override
protected void setOutTupleRightFact(QuadTupleImpl<A, B, C, D> outTuple, UniTuple<D> rightTuple) {
outTuple.factD = rightTuple.getFactA();
}
@Override
protected boolean testFiltering(TriTuple<A, B, C> leftTuple, UniTuple<D> rightTuple) {
return filtering.test(leftTuple.getFactA(), leftTuple.getFactB(), leftTuple.getFactC(), rightTuple.getFactA());
}
}
|
outTuple.factA = leftTuple.getFactA();
outTuple.factB = leftTuple.getFactB();
outTuple.factC = leftTuple.getFactC();
| 630
| 54
| 684
|
<methods>public final void insertLeft(TriTuple<A,B,C>) ,public final void insertRight(UniTuple<D>) ,public final void retractLeft(TriTuple<A,B,C>) ,public final void retractRight(UniTuple<D>) ,public final void updateLeft(TriTuple<A,B,C>) ,public final void updateRight(UniTuple<D>) <variables>private final non-sealed int inputStoreIndexLeftEntry,private final non-sealed int inputStoreIndexRightEntry,private final TupleList<TriTuple<A,B,C>> leftTupleList,private final TupleList<UniTuple<D>> rightTupleList
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/tri/BavetFilterTriConstraintStream.java
|
BavetFilterTriConstraintStream
|
equals
|
class BavetFilterTriConstraintStream<Solution_, A, B, C>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final BavetAbstractTriConstraintStream<Solution_, A, B, C> parent;
private final TriPredicate<A, B, C> predicate;
public BavetFilterTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent,
TriPredicate<A, B, C> predicate) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
this.predicate = predicate;
if (predicate == null) {
throw new IllegalArgumentException("The predicate (null) cannot be null.");
}
}
@Override
public boolean guaranteesDistinct() {
return parent.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parent.getTupleSource();
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
buildHelper.<TriTuple<A, B, C>> putInsertUpdateRetract(this, childStreamList,
tupleLifecycle -> new ConditionalTriTupleLifecycle<>(predicate, tupleLifecycle));
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public int hashCode() {
return Objects.hash(parent, predicate);
}
@Override
public boolean equals(Object o) {<FILL_FUNCTION_BODY>}
@Override
public String toString() {
return "Filter() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
if (this == o) {
return true;
} else if (o instanceof BavetFilterTriConstraintStream) {
BavetFilterTriConstraintStream<?, ?, ?, ?> other = (BavetFilterTriConstraintStream<?, ?, ?, ?>) o;
return parent == other.parent
&& predicate == other.predicate;
} else {
return false;
}
| 585
| 103
| 688
|
<methods>public void <init>(BavetConstraintFactory<Solution_>, org.optaplanner.constraint.streams.common.RetrievalSemantics) ,public BavetAbstractTriConstraintStream<Solution_,A,B,C> filter(TriPredicate<A,B,C>) ,public TriConstraintStream<A,B,ResultC_> flattenLast(Function<C,Iterable<ResultC_>>) ,public List<BavetAbstractTriConstraintStream<Solution_,A,B,C>> getChildStreamList() ,public UniConstraintStream<Result_> groupBy(TriConstraintCollector<A,B,C,ResultContainer_,Result_>) ,public BiConstraintStream<ResultA_,ResultB_> groupBy(TriConstraintCollector<A,B,C,ResultContainerA_,ResultA_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>) ,public TriConstraintStream<ResultA_,ResultB_,ResultC_> groupBy(TriConstraintCollector<A,B,C,ResultContainerA_,ResultA_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_> groupBy(TriConstraintCollector<A,B,C,ResultContainerA_,ResultA_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>, TriConstraintCollector<A,B,C,ResultContainerD_,ResultD_>) ,public UniConstraintStream<GroupKey_> groupBy(TriFunction<A,B,C,GroupKey_>) ,public TriConstraintStream<GroupKey_,ResultB_,ResultC_> groupBy(TriFunction<A,B,C,GroupKey_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_> groupBy(TriFunction<A,B,C,GroupKey_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>, TriConstraintCollector<A,B,C,ResultContainerD_,ResultD_>) ,public BiConstraintStream<GroupKey_,Result_> groupBy(TriFunction<A,B,C,GroupKey_>, TriConstraintCollector<A,B,C,ResultContainer_,Result_>) ,public BiConstraintStream<GroupKeyA_,GroupKeyB_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriConstraintCollector<A,B,C,ResultContainer_,Result_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>, TriConstraintCollector<A,B,C,ResultContainerD_,ResultD_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriFunction<A,B,C,GroupKeyC_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriFunction<A,B,C,GroupKeyC_>, TriConstraintCollector<A,B,C,ResultContainerD_,ResultD_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriFunction<A,B,C,GroupKeyC_>, TriFunction<A,B,C,GroupKeyD_>) ,public final transient TriConstraintStream<A,B,C> ifExists(Class<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifExists(UniConstraintStream<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifExistsIncludingNullVars(Class<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifNotExists(Class<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifNotExists(UniConstraintStream<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifNotExistsIncludingNullVars(Class<D>, QuadJoiner<A,B,C,D>[]) ,public TriConstraintBuilder<A,B,C,Score_> innerImpact(Score_, ToIntTriFunction<A,B,C>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public TriConstraintBuilder<A,B,C,Score_> innerImpact(Score_, ToLongTriFunction<A,B,C>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public TriConstraintBuilder<A,B,C,Score_> innerImpact(Score_, TriFunction<A,B,C,java.math.BigDecimal>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public final transient QuadConstraintStream<A,B,C,D> join(UniConstraintStream<D>, QuadJoiner<A,B,C,D>[]) ,public UniConstraintStream<ResultA_> map(TriFunction<A,B,C,ResultA_>) ,public Stream_ shareAndAddChild(Stream_) <variables>protected final List<BavetAbstractTriConstraintStream<Solution_,A,B,C>> childStreamList
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/tri/BavetFlattenLastTriConstraintStream.java
|
BavetFlattenLastTriConstraintStream
|
toString
|
class BavetFlattenLastTriConstraintStream<Solution_, A, B, C>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final BavetAbstractConstraintStream<Solution_> parent;
public BavetFlattenLastTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractConstraintStream<Solution_> parent) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
}
@Override
public boolean guaranteesDistinct() {
return false;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
// Do nothing. BavetFlattenLastBridgeUniConstraintStream, etc build everything.
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
// TODO
@Override
public String toString() {<FILL_FUNCTION_BODY>}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
return "FlattenLast() with " + childStreamList.size() + " children";
| 373
| 25
| 398
|
<methods>public void <init>(BavetConstraintFactory<Solution_>, org.optaplanner.constraint.streams.common.RetrievalSemantics) ,public BavetAbstractTriConstraintStream<Solution_,A,B,C> filter(TriPredicate<A,B,C>) ,public TriConstraintStream<A,B,ResultC_> flattenLast(Function<C,Iterable<ResultC_>>) ,public List<BavetAbstractTriConstraintStream<Solution_,A,B,C>> getChildStreamList() ,public UniConstraintStream<Result_> groupBy(TriConstraintCollector<A,B,C,ResultContainer_,Result_>) ,public BiConstraintStream<ResultA_,ResultB_> groupBy(TriConstraintCollector<A,B,C,ResultContainerA_,ResultA_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>) ,public TriConstraintStream<ResultA_,ResultB_,ResultC_> groupBy(TriConstraintCollector<A,B,C,ResultContainerA_,ResultA_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_> groupBy(TriConstraintCollector<A,B,C,ResultContainerA_,ResultA_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>, TriConstraintCollector<A,B,C,ResultContainerD_,ResultD_>) ,public UniConstraintStream<GroupKey_> groupBy(TriFunction<A,B,C,GroupKey_>) ,public TriConstraintStream<GroupKey_,ResultB_,ResultC_> groupBy(TriFunction<A,B,C,GroupKey_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_> groupBy(TriFunction<A,B,C,GroupKey_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>, TriConstraintCollector<A,B,C,ResultContainerD_,ResultD_>) ,public BiConstraintStream<GroupKey_,Result_> groupBy(TriFunction<A,B,C,GroupKey_>, TriConstraintCollector<A,B,C,ResultContainer_,Result_>) ,public BiConstraintStream<GroupKeyA_,GroupKeyB_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriConstraintCollector<A,B,C,ResultContainer_,Result_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>, TriConstraintCollector<A,B,C,ResultContainerD_,ResultD_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriFunction<A,B,C,GroupKeyC_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriFunction<A,B,C,GroupKeyC_>, TriConstraintCollector<A,B,C,ResultContainerD_,ResultD_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriFunction<A,B,C,GroupKeyC_>, TriFunction<A,B,C,GroupKeyD_>) ,public final transient TriConstraintStream<A,B,C> ifExists(Class<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifExists(UniConstraintStream<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifExistsIncludingNullVars(Class<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifNotExists(Class<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifNotExists(UniConstraintStream<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifNotExistsIncludingNullVars(Class<D>, QuadJoiner<A,B,C,D>[]) ,public TriConstraintBuilder<A,B,C,Score_> innerImpact(Score_, ToIntTriFunction<A,B,C>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public TriConstraintBuilder<A,B,C,Score_> innerImpact(Score_, ToLongTriFunction<A,B,C>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public TriConstraintBuilder<A,B,C,Score_> innerImpact(Score_, TriFunction<A,B,C,java.math.BigDecimal>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public final transient QuadConstraintStream<A,B,C,D> join(UniConstraintStream<D>, QuadJoiner<A,B,C,D>[]) ,public UniConstraintStream<ResultA_> map(TriFunction<A,B,C,ResultA_>) ,public Stream_ shareAndAddChild(Stream_) <variables>protected final List<BavetAbstractTriConstraintStream<Solution_,A,B,C>> childStreamList
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/tri/BavetGroupTriConstraintStream.java
|
BavetGroupTriConstraintStream
|
toString
|
class BavetGroupTriConstraintStream<Solution_, A, B, C>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final BavetAbstractConstraintStream<Solution_> parent;
public BavetGroupTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractConstraintStream<Solution_> parent) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
// Do nothing. BavetGroupBridgeUniConstraintStream, etc build everything.
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
// TODO
@Override
public String toString() {<FILL_FUNCTION_BODY>}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
return "Group() with " + childStreamList.size() + " children";
| 364
| 22
| 386
|
<methods>public void <init>(BavetConstraintFactory<Solution_>, org.optaplanner.constraint.streams.common.RetrievalSemantics) ,public BavetAbstractTriConstraintStream<Solution_,A,B,C> filter(TriPredicate<A,B,C>) ,public TriConstraintStream<A,B,ResultC_> flattenLast(Function<C,Iterable<ResultC_>>) ,public List<BavetAbstractTriConstraintStream<Solution_,A,B,C>> getChildStreamList() ,public UniConstraintStream<Result_> groupBy(TriConstraintCollector<A,B,C,ResultContainer_,Result_>) ,public BiConstraintStream<ResultA_,ResultB_> groupBy(TriConstraintCollector<A,B,C,ResultContainerA_,ResultA_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>) ,public TriConstraintStream<ResultA_,ResultB_,ResultC_> groupBy(TriConstraintCollector<A,B,C,ResultContainerA_,ResultA_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_> groupBy(TriConstraintCollector<A,B,C,ResultContainerA_,ResultA_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>, TriConstraintCollector<A,B,C,ResultContainerD_,ResultD_>) ,public UniConstraintStream<GroupKey_> groupBy(TriFunction<A,B,C,GroupKey_>) ,public TriConstraintStream<GroupKey_,ResultB_,ResultC_> groupBy(TriFunction<A,B,C,GroupKey_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_> groupBy(TriFunction<A,B,C,GroupKey_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>, TriConstraintCollector<A,B,C,ResultContainerD_,ResultD_>) ,public BiConstraintStream<GroupKey_,Result_> groupBy(TriFunction<A,B,C,GroupKey_>, TriConstraintCollector<A,B,C,ResultContainer_,Result_>) ,public BiConstraintStream<GroupKeyA_,GroupKeyB_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriConstraintCollector<A,B,C,ResultContainer_,Result_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>, TriConstraintCollector<A,B,C,ResultContainerD_,ResultD_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriFunction<A,B,C,GroupKeyC_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriFunction<A,B,C,GroupKeyC_>, TriConstraintCollector<A,B,C,ResultContainerD_,ResultD_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriFunction<A,B,C,GroupKeyC_>, TriFunction<A,B,C,GroupKeyD_>) ,public final transient TriConstraintStream<A,B,C> ifExists(Class<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifExists(UniConstraintStream<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifExistsIncludingNullVars(Class<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifNotExists(Class<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifNotExists(UniConstraintStream<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifNotExistsIncludingNullVars(Class<D>, QuadJoiner<A,B,C,D>[]) ,public TriConstraintBuilder<A,B,C,Score_> innerImpact(Score_, ToIntTriFunction<A,B,C>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public TriConstraintBuilder<A,B,C,Score_> innerImpact(Score_, ToLongTriFunction<A,B,C>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public TriConstraintBuilder<A,B,C,Score_> innerImpact(Score_, TriFunction<A,B,C,java.math.BigDecimal>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public final transient QuadConstraintStream<A,B,C,D> join(UniConstraintStream<D>, QuadJoiner<A,B,C,D>[]) ,public UniConstraintStream<ResultA_> map(TriFunction<A,B,C,ResultA_>) ,public Stream_ shareAndAddChild(Stream_) <variables>protected final List<BavetAbstractTriConstraintStream<Solution_,A,B,C>> childStreamList
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/tri/BavetIfExistsTriConstraintStream.java
|
BavetIfExistsTriConstraintStream
|
buildNode
|
class BavetIfExistsTriConstraintStream<Solution_, A, B, C, D>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final BavetAbstractTriConstraintStream<Solution_, A, B, C> parentABC;
private final BavetIfExistsBridgeUniConstraintStream<Solution_, D> parentBridgeD;
private final boolean shouldExist;
private final DefaultQuadJoiner<A, B, C, D> joiner;
private final QuadPredicate<A, B, C, D> filtering;
public BavetIfExistsTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parentABC,
BavetIfExistsBridgeUniConstraintStream<Solution_, D> parentBridgeD,
boolean shouldExist,
DefaultQuadJoiner<A, B, C, D> joiner, QuadPredicate<A, B, C, D> filtering) {
super(constraintFactory, parentABC.getRetrievalSemantics());
this.parentABC = parentABC;
this.parentBridgeD = parentBridgeD;
this.shouldExist = shouldExist;
this.joiner = joiner;
this.filtering = filtering;
}
@Override
public boolean guaranteesDistinct() {
return parentABC.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parentABC.collectActiveConstraintStreams(constraintStreamSet);
parentBridgeD.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parentABC.getTupleSource();
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {<FILL_FUNCTION_BODY>}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
// TODO
@Override
public String toString() {
return "IfExists() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
TupleLifecycle<TriTuple<A, B, C>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
IndexerFactory indexerFactory = new IndexerFactory(joiner);
AbstractIfExistsNode<TriTuple<A, B, C>, D> node = indexerFactory.hasJoiners()
? (filtering == null ? new IndexedIfExistsTriNode<>(shouldExist,
JoinerUtils.combineLeftMappings(joiner), JoinerUtils.combineRightMappings(joiner),
buildHelper.reserveTupleStoreIndex(parentABC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentABC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeD.getTupleSource()),
downstream, indexerFactory.buildIndexer(true), indexerFactory.buildIndexer(false))
: new IndexedIfExistsTriNode<>(shouldExist,
JoinerUtils.combineLeftMappings(joiner), JoinerUtils.combineRightMappings(joiner),
buildHelper.reserveTupleStoreIndex(parentABC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentABC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentABC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeD.getTupleSource()),
downstream, indexerFactory.buildIndexer(true), indexerFactory.buildIndexer(false),
filtering))
: (filtering == null ? new UnindexedIfExistsTriNode<>(shouldExist,
buildHelper.reserveTupleStoreIndex(parentABC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeD.getTupleSource()), downstream)
: new UnindexedIfExistsTriNode<>(shouldExist,
buildHelper.reserveTupleStoreIndex(parentABC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentABC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeD.getTupleSource()),
downstream, filtering));
buildHelper.addNode(node, this, parentBridgeD);
| 642
| 648
| 1,290
|
<methods>public void <init>(BavetConstraintFactory<Solution_>, org.optaplanner.constraint.streams.common.RetrievalSemantics) ,public BavetAbstractTriConstraintStream<Solution_,A,B,C> filter(TriPredicate<A,B,C>) ,public TriConstraintStream<A,B,ResultC_> flattenLast(Function<C,Iterable<ResultC_>>) ,public List<BavetAbstractTriConstraintStream<Solution_,A,B,C>> getChildStreamList() ,public UniConstraintStream<Result_> groupBy(TriConstraintCollector<A,B,C,ResultContainer_,Result_>) ,public BiConstraintStream<ResultA_,ResultB_> groupBy(TriConstraintCollector<A,B,C,ResultContainerA_,ResultA_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>) ,public TriConstraintStream<ResultA_,ResultB_,ResultC_> groupBy(TriConstraintCollector<A,B,C,ResultContainerA_,ResultA_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_> groupBy(TriConstraintCollector<A,B,C,ResultContainerA_,ResultA_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>, TriConstraintCollector<A,B,C,ResultContainerD_,ResultD_>) ,public UniConstraintStream<GroupKey_> groupBy(TriFunction<A,B,C,GroupKey_>) ,public TriConstraintStream<GroupKey_,ResultB_,ResultC_> groupBy(TriFunction<A,B,C,GroupKey_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_> groupBy(TriFunction<A,B,C,GroupKey_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>, TriConstraintCollector<A,B,C,ResultContainerD_,ResultD_>) ,public BiConstraintStream<GroupKey_,Result_> groupBy(TriFunction<A,B,C,GroupKey_>, TriConstraintCollector<A,B,C,ResultContainer_,Result_>) ,public BiConstraintStream<GroupKeyA_,GroupKeyB_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriConstraintCollector<A,B,C,ResultContainer_,Result_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>, TriConstraintCollector<A,B,C,ResultContainerD_,ResultD_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriFunction<A,B,C,GroupKeyC_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriFunction<A,B,C,GroupKeyC_>, TriConstraintCollector<A,B,C,ResultContainerD_,ResultD_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriFunction<A,B,C,GroupKeyC_>, TriFunction<A,B,C,GroupKeyD_>) ,public final transient TriConstraintStream<A,B,C> ifExists(Class<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifExists(UniConstraintStream<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifExistsIncludingNullVars(Class<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifNotExists(Class<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifNotExists(UniConstraintStream<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifNotExistsIncludingNullVars(Class<D>, QuadJoiner<A,B,C,D>[]) ,public TriConstraintBuilder<A,B,C,Score_> innerImpact(Score_, ToIntTriFunction<A,B,C>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public TriConstraintBuilder<A,B,C,Score_> innerImpact(Score_, ToLongTriFunction<A,B,C>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public TriConstraintBuilder<A,B,C,Score_> innerImpact(Score_, TriFunction<A,B,C,java.math.BigDecimal>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public final transient QuadConstraintStream<A,B,C,D> join(UniConstraintStream<D>, QuadJoiner<A,B,C,D>[]) ,public UniConstraintStream<ResultA_> map(TriFunction<A,B,C,ResultA_>) ,public Stream_ shareAndAddChild(Stream_) <variables>protected final List<BavetAbstractTriConstraintStream<Solution_,A,B,C>> childStreamList
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/tri/BavetJoinTriConstraintStream.java
|
BavetJoinTriConstraintStream
|
buildNode
|
class BavetJoinTriConstraintStream<Solution_, A, B, C>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C>
implements BavetJoinConstraintStream<Solution_> {
private final BavetJoinBridgeBiConstraintStream<Solution_, A, B> leftParent;
private final BavetJoinBridgeUniConstraintStream<Solution_, C> rightParent;
private final DefaultTriJoiner<A, B, C> joiner;
private final TriPredicate<A, B, C> filtering;
public BavetJoinTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetJoinBridgeBiConstraintStream<Solution_, A, B> leftParent,
BavetJoinBridgeUniConstraintStream<Solution_, C> rightParent,
DefaultTriJoiner<A, B, C> joiner, TriPredicate<A, B, C> filtering) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.joiner = joiner;
this.filtering = filtering;
}
@Override
public boolean guaranteesDistinct() {
return leftParent.guaranteesDistinct() && rightParent.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
leftParent.collectActiveConstraintStreams(constraintStreamSet);
rightParent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {<FILL_FUNCTION_BODY>}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
BavetJoinTriConstraintStream<?, ?, ?, ?> other = (BavetJoinTriConstraintStream<?, ?, ?, ?>) o;
/*
* Bridge streams do not implement equality because their equals() would have to point back to this stream,
* resulting in StackOverflowError.
* Therefore we need to check bridge parents to see where this join node comes from.
*/
return Objects.equals(leftParent.getParent(), other.leftParent.getParent())
&& Objects.equals(rightParent.getParent(), other.rightParent.getParent())
&& Objects.equals(joiner, other.joiner)
&& Objects.equals(filtering, other.filtering);
}
@Override
public int hashCode() {
return Objects.hash(leftParent.getParent(), rightParent.getParent(), joiner, filtering);
}
@Override
public String toString() {
return "TriJoin() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
int outputStoreSize = buildHelper.extractTupleStoreSize(this);
TupleLifecycle<TriTuple<A, B, C>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
IndexerFactory indexerFactory = new IndexerFactory(joiner);
AbstractJoinNode<BiTuple<A, B>, C, TriTuple<A, B, C>, TriTupleImpl<A, B, C>> node = indexerFactory.hasJoiners()
? new IndexedJoinTriNode<>(
JoinerUtils.combineLeftMappings(joiner), JoinerUtils.combineRightMappings(joiner),
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
downstream, filtering, outputStoreSize + 2,
outputStoreSize, outputStoreSize + 1,
indexerFactory.buildIndexer(true), indexerFactory.buildIndexer(false))
: new UnindexedJoinTriNode<>(
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
downstream, filtering, outputStoreSize + 2,
outputStoreSize, outputStoreSize + 1);
buildHelper.addNode(node, leftParent, rightParent);
| 832
| 466
| 1,298
|
<methods>public void <init>(BavetConstraintFactory<Solution_>, org.optaplanner.constraint.streams.common.RetrievalSemantics) ,public BavetAbstractTriConstraintStream<Solution_,A,B,C> filter(TriPredicate<A,B,C>) ,public TriConstraintStream<A,B,ResultC_> flattenLast(Function<C,Iterable<ResultC_>>) ,public List<BavetAbstractTriConstraintStream<Solution_,A,B,C>> getChildStreamList() ,public UniConstraintStream<Result_> groupBy(TriConstraintCollector<A,B,C,ResultContainer_,Result_>) ,public BiConstraintStream<ResultA_,ResultB_> groupBy(TriConstraintCollector<A,B,C,ResultContainerA_,ResultA_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>) ,public TriConstraintStream<ResultA_,ResultB_,ResultC_> groupBy(TriConstraintCollector<A,B,C,ResultContainerA_,ResultA_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_> groupBy(TriConstraintCollector<A,B,C,ResultContainerA_,ResultA_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>, TriConstraintCollector<A,B,C,ResultContainerD_,ResultD_>) ,public UniConstraintStream<GroupKey_> groupBy(TriFunction<A,B,C,GroupKey_>) ,public TriConstraintStream<GroupKey_,ResultB_,ResultC_> groupBy(TriFunction<A,B,C,GroupKey_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_> groupBy(TriFunction<A,B,C,GroupKey_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>, TriConstraintCollector<A,B,C,ResultContainerD_,ResultD_>) ,public BiConstraintStream<GroupKey_,Result_> groupBy(TriFunction<A,B,C,GroupKey_>, TriConstraintCollector<A,B,C,ResultContainer_,Result_>) ,public BiConstraintStream<GroupKeyA_,GroupKeyB_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriConstraintCollector<A,B,C,ResultContainer_,Result_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>, TriConstraintCollector<A,B,C,ResultContainerD_,ResultD_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriFunction<A,B,C,GroupKeyC_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriFunction<A,B,C,GroupKeyC_>, TriConstraintCollector<A,B,C,ResultContainerD_,ResultD_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriFunction<A,B,C,GroupKeyC_>, TriFunction<A,B,C,GroupKeyD_>) ,public final transient TriConstraintStream<A,B,C> ifExists(Class<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifExists(UniConstraintStream<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifExistsIncludingNullVars(Class<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifNotExists(Class<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifNotExists(UniConstraintStream<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifNotExistsIncludingNullVars(Class<D>, QuadJoiner<A,B,C,D>[]) ,public TriConstraintBuilder<A,B,C,Score_> innerImpact(Score_, ToIntTriFunction<A,B,C>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public TriConstraintBuilder<A,B,C,Score_> innerImpact(Score_, ToLongTriFunction<A,B,C>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public TriConstraintBuilder<A,B,C,Score_> innerImpact(Score_, TriFunction<A,B,C,java.math.BigDecimal>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public final transient QuadConstraintStream<A,B,C,D> join(UniConstraintStream<D>, QuadJoiner<A,B,C,D>[]) ,public UniConstraintStream<ResultA_> map(TriFunction<A,B,C,ResultA_>) ,public Stream_ shareAndAddChild(Stream_) <variables>protected final List<BavetAbstractTriConstraintStream<Solution_,A,B,C>> childStreamList
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/tri/BavetMapBridgeTriConstraintStream.java
|
BavetMapBridgeTriConstraintStream
|
buildNode
|
class BavetMapBridgeTriConstraintStream<Solution_, A, B, C, NewA>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final BavetAbstractTriConstraintStream<Solution_, A, B, C> parent;
private final TriFunction<A, B, C, NewA> mappingFunction;
private BavetMapUniConstraintStream<Solution_, NewA> mapStream;
public BavetMapBridgeTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent, TriFunction<A, B, C, NewA> mappingFunction) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
this.mappingFunction = mappingFunction;
}
@Override
public boolean guaranteesDistinct() {
return false;
}
public void setMapStream(BavetMapUniConstraintStream<Solution_, NewA> mapStream) {
this.mapStream = mapStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parent.getTupleSource();
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {<FILL_FUNCTION_BODY>}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
// TODO
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
if (!childStreamList.isEmpty()) {
throw new IllegalStateException("Impossible state: the stream (" + this
+ ") has a non-empty childStreamList (" + childStreamList + ") but it's a flattenLast bridge.");
}
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(mapStream);
AbstractMapNode<TriTuple<A, B, C>, NewA> node = new MapTriNode<>(inputStoreIndex, mappingFunction,
buildHelper.getAggregatedTupleLifecycle(mapStream.getChildStreamList()), outputStoreSize);
buildHelper.addNode(node, this);
| 490
| 181
| 671
|
<methods>public void <init>(BavetConstraintFactory<Solution_>, org.optaplanner.constraint.streams.common.RetrievalSemantics) ,public BavetAbstractTriConstraintStream<Solution_,A,B,C> filter(TriPredicate<A,B,C>) ,public TriConstraintStream<A,B,ResultC_> flattenLast(Function<C,Iterable<ResultC_>>) ,public List<BavetAbstractTriConstraintStream<Solution_,A,B,C>> getChildStreamList() ,public UniConstraintStream<Result_> groupBy(TriConstraintCollector<A,B,C,ResultContainer_,Result_>) ,public BiConstraintStream<ResultA_,ResultB_> groupBy(TriConstraintCollector<A,B,C,ResultContainerA_,ResultA_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>) ,public TriConstraintStream<ResultA_,ResultB_,ResultC_> groupBy(TriConstraintCollector<A,B,C,ResultContainerA_,ResultA_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_> groupBy(TriConstraintCollector<A,B,C,ResultContainerA_,ResultA_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>, TriConstraintCollector<A,B,C,ResultContainerD_,ResultD_>) ,public UniConstraintStream<GroupKey_> groupBy(TriFunction<A,B,C,GroupKey_>) ,public TriConstraintStream<GroupKey_,ResultB_,ResultC_> groupBy(TriFunction<A,B,C,GroupKey_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_> groupBy(TriFunction<A,B,C,GroupKey_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>, TriConstraintCollector<A,B,C,ResultContainerD_,ResultD_>) ,public BiConstraintStream<GroupKey_,Result_> groupBy(TriFunction<A,B,C,GroupKey_>, TriConstraintCollector<A,B,C,ResultContainer_,Result_>) ,public BiConstraintStream<GroupKeyA_,GroupKeyB_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriConstraintCollector<A,B,C,ResultContainer_,Result_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>, TriConstraintCollector<A,B,C,ResultContainerD_,ResultD_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriFunction<A,B,C,GroupKeyC_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriFunction<A,B,C,GroupKeyC_>, TriConstraintCollector<A,B,C,ResultContainerD_,ResultD_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriFunction<A,B,C,GroupKeyC_>, TriFunction<A,B,C,GroupKeyD_>) ,public final transient TriConstraintStream<A,B,C> ifExists(Class<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifExists(UniConstraintStream<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifExistsIncludingNullVars(Class<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifNotExists(Class<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifNotExists(UniConstraintStream<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifNotExistsIncludingNullVars(Class<D>, QuadJoiner<A,B,C,D>[]) ,public TriConstraintBuilder<A,B,C,Score_> innerImpact(Score_, ToIntTriFunction<A,B,C>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public TriConstraintBuilder<A,B,C,Score_> innerImpact(Score_, ToLongTriFunction<A,B,C>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public TriConstraintBuilder<A,B,C,Score_> innerImpact(Score_, TriFunction<A,B,C,java.math.BigDecimal>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public final transient QuadConstraintStream<A,B,C,D> join(UniConstraintStream<D>, QuadJoiner<A,B,C,D>[]) ,public UniConstraintStream<ResultA_> map(TriFunction<A,B,C,ResultA_>) ,public Stream_ shareAndAddChild(Stream_) <variables>protected final List<BavetAbstractTriConstraintStream<Solution_,A,B,C>> childStreamList
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/tri/BavetTriGroupBridgeTriConstraintStream.java
|
BavetTriGroupBridgeTriConstraintStream
|
buildNode
|
class BavetTriGroupBridgeTriConstraintStream<Solution_, A, B, C, NewA, NewB, NewC>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final BavetAbstractTriConstraintStream<Solution_, A, B, C> parent;
private BavetGroupTriConstraintStream<Solution_, NewA, NewB, NewC> groupStream;
private final GroupNodeConstructor<TriTuple<NewA, NewB, NewC>> nodeConstructor;
public BavetTriGroupBridgeTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent,
GroupNodeConstructor<TriTuple<NewA, NewB, NewC>> nodeConstructor) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
this.nodeConstructor = nodeConstructor;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
public void setGroupStream(BavetGroupTriConstraintStream<Solution_, NewA, NewB, NewC> groupStream) {
this.groupStream = groupStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {<FILL_FUNCTION_BODY>}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parent.getTupleSource();
}
}
|
List<? extends ConstraintStream> groupStreamChildList = groupStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), groupStream, groupStreamChildList, this, childStreamList,
constraintFactory.getEnvironmentMode());
| 469
| 66
| 535
|
<methods>public void <init>(BavetConstraintFactory<Solution_>, org.optaplanner.constraint.streams.common.RetrievalSemantics) ,public BavetAbstractTriConstraintStream<Solution_,A,B,C> filter(TriPredicate<A,B,C>) ,public TriConstraintStream<A,B,ResultC_> flattenLast(Function<C,Iterable<ResultC_>>) ,public List<BavetAbstractTriConstraintStream<Solution_,A,B,C>> getChildStreamList() ,public UniConstraintStream<Result_> groupBy(TriConstraintCollector<A,B,C,ResultContainer_,Result_>) ,public BiConstraintStream<ResultA_,ResultB_> groupBy(TriConstraintCollector<A,B,C,ResultContainerA_,ResultA_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>) ,public TriConstraintStream<ResultA_,ResultB_,ResultC_> groupBy(TriConstraintCollector<A,B,C,ResultContainerA_,ResultA_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_> groupBy(TriConstraintCollector<A,B,C,ResultContainerA_,ResultA_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>, TriConstraintCollector<A,B,C,ResultContainerD_,ResultD_>) ,public UniConstraintStream<GroupKey_> groupBy(TriFunction<A,B,C,GroupKey_>) ,public TriConstraintStream<GroupKey_,ResultB_,ResultC_> groupBy(TriFunction<A,B,C,GroupKey_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_> groupBy(TriFunction<A,B,C,GroupKey_>, TriConstraintCollector<A,B,C,ResultContainerB_,ResultB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>, TriConstraintCollector<A,B,C,ResultContainerD_,ResultD_>) ,public BiConstraintStream<GroupKey_,Result_> groupBy(TriFunction<A,B,C,GroupKey_>, TriConstraintCollector<A,B,C,ResultContainer_,Result_>) ,public BiConstraintStream<GroupKeyA_,GroupKeyB_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriConstraintCollector<A,B,C,ResultContainer_,Result_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriConstraintCollector<A,B,C,ResultContainerC_,ResultC_>, TriConstraintCollector<A,B,C,ResultContainerD_,ResultD_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriFunction<A,B,C,GroupKeyC_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriFunction<A,B,C,GroupKeyC_>, TriConstraintCollector<A,B,C,ResultContainerD_,ResultD_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> groupBy(TriFunction<A,B,C,GroupKeyA_>, TriFunction<A,B,C,GroupKeyB_>, TriFunction<A,B,C,GroupKeyC_>, TriFunction<A,B,C,GroupKeyD_>) ,public final transient TriConstraintStream<A,B,C> ifExists(Class<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifExists(UniConstraintStream<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifExistsIncludingNullVars(Class<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifNotExists(Class<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifNotExists(UniConstraintStream<D>, QuadJoiner<A,B,C,D>[]) ,public final transient TriConstraintStream<A,B,C> ifNotExistsIncludingNullVars(Class<D>, QuadJoiner<A,B,C,D>[]) ,public TriConstraintBuilder<A,B,C,Score_> innerImpact(Score_, ToIntTriFunction<A,B,C>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public TriConstraintBuilder<A,B,C,Score_> innerImpact(Score_, ToLongTriFunction<A,B,C>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public TriConstraintBuilder<A,B,C,Score_> innerImpact(Score_, TriFunction<A,B,C,java.math.BigDecimal>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public final transient QuadConstraintStream<A,B,C,D> join(UniConstraintStream<D>, QuadJoiner<A,B,C,D>[]) ,public UniConstraintStream<ResultA_> map(TriFunction<A,B,C,ResultA_>) ,public Stream_ shareAndAddChild(Stream_) <variables>protected final List<BavetAbstractTriConstraintStream<Solution_,A,B,C>> childStreamList
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/tri/Group0Mapping2CollectorTriNode.java
|
Group0Mapping2CollectorTriNode
|
mergeCollectors
|
class Group0Mapping2CollectorTriNode<OldA, OldB, OldC, A, B, ResultContainerA_, ResultContainerB_>
extends AbstractGroupTriNode<OldA, OldB, OldC, BiTuple<A, B>, BiTupleImpl<A, B>, Void, Object, Pair<A, B>> {
private final int outputStoreSize;
public Group0Mapping2CollectorTriNode(int groupStoreIndex, int undoStoreIndex,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerA_, A> collectorA,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerB_, B> collectorB,
TupleLifecycle<BiTuple<A, B>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex, null, mergeCollectors(collectorA, collectorB), nextNodesTupleLifecycle,
environmentMode);
this.outputStoreSize = outputStoreSize;
}
static <OldA, OldB, OldC, A, B, ResultContainerA_, ResultContainerB_>
TriConstraintCollector<OldA, OldB, OldC, Object, Pair<A, B>> mergeCollectors(
TriConstraintCollector<OldA, OldB, OldC, ResultContainerA_, A> collectorA,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerB_, B> collectorB) {<FILL_FUNCTION_BODY>}
@Override
protected BiTupleImpl<A, B> createOutTuple(Void groupKey) {
return new BiTupleImpl<>(null, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(BiTupleImpl<A, B> outTuple, Pair<A, B> result) {
outTuple.factA = result.getKey();
outTuple.factB = result.getValue();
}
}
|
return (TriConstraintCollector<OldA, OldB, OldC, Object, Pair<A, B>>) ConstraintCollectors.compose(collectorA,
collectorB,
Pair::of);
| 498
| 55
| 553
|
<methods><variables>private final non-sealed QuadFunction<java.lang.Object,OldA,OldB,OldC,java.lang.Runnable> accumulator
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/tri/Group3Mapping0CollectorTriNode.java
|
Group3Mapping0CollectorTriNode
|
createGroupKey
|
class Group3Mapping0CollectorTriNode<OldA, OldB, OldC, A, B, C>
extends AbstractGroupTriNode<OldA, OldB, OldC, TriTuple<A, B, C>, TriTupleImpl<A, B, C>, Triple<A, B, C>, Void, Void> {
private final int outputStoreSize;
public Group3Mapping0CollectorTriNode(TriFunction<OldA, OldB, OldC, A> groupKeyMappingA,
TriFunction<OldA, OldB, OldC, B> groupKeyMappingB, TriFunction<OldA, OldB, OldC, C> groupKeyMappingC,
int groupStoreIndex, TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle, int outputStoreSize,
EnvironmentMode environmentMode) {
super(groupStoreIndex, tuple -> createGroupKey(groupKeyMappingA, groupKeyMappingB, groupKeyMappingC, tuple),
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
static <A, B, C, OldA, OldB, OldC> Triple<A, B, C> createGroupKey(TriFunction<OldA, OldB, OldC, A> groupKeyMappingA,
TriFunction<OldA, OldB, OldC, B> groupKeyMappingB, TriFunction<OldA, OldB, OldC, C> groupKeyMappingC,
TriTuple<OldA, OldB, OldC> tuple) {<FILL_FUNCTION_BODY>}
@Override
protected TriTupleImpl<A, B, C> createOutTuple(Triple<A, B, C> groupKey) {
return new TriTupleImpl<>(groupKey.getA(), groupKey.getB(), groupKey.getC(), outputStoreSize);
}
@Override
protected void updateOutTupleToResult(TriTupleImpl<A, B, C> outTuple, Void unused) {
throw new IllegalStateException("Impossible state: collector is null.");
}
}
|
OldA oldA = tuple.getFactA();
OldB oldB = tuple.getFactB();
OldC oldC = tuple.getFactC();
A a = groupKeyMappingA.apply(oldA, oldB, oldC);
B b = groupKeyMappingB.apply(oldA, oldB, oldC);
C c = groupKeyMappingC.apply(oldA, oldB, oldC);
return Triple.of(a, b, c);
| 524
| 119
| 643
|
<methods><variables>private final non-sealed QuadFunction<java.lang.Void,OldA,OldB,OldC,java.lang.Runnable> accumulator
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/tri/Group4Mapping0CollectorTriNode.java
|
Group4Mapping0CollectorTriNode
|
createGroupKey
|
class Group4Mapping0CollectorTriNode<OldA, OldB, OldC, A, B, C, D>
extends
AbstractGroupTriNode<OldA, OldB, OldC, QuadTuple<A, B, C, D>, QuadTupleImpl<A, B, C, D>, Quadruple<A, B, C, D>, Void, Void> {
private final int outputStoreSize;
public Group4Mapping0CollectorTriNode(TriFunction<OldA, OldB, OldC, A> groupKeyMappingA,
TriFunction<OldA, OldB, OldC, B> groupKeyMappingB, TriFunction<OldA, OldB, OldC, C> groupKeyMappingC,
TriFunction<OldA, OldB, OldC, D> groupKeyMappingD, int groupStoreIndex,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle, int outputStoreSize,
EnvironmentMode environmentMode) {
super(groupStoreIndex,
tuple -> createGroupKey(groupKeyMappingA, groupKeyMappingB, groupKeyMappingC, groupKeyMappingD, tuple),
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
private static <A, B, C, D, OldA, OldB, OldC> Quadruple<A, B, C, D> createGroupKey(
TriFunction<OldA, OldB, OldC, A> groupKeyMappingA,
TriFunction<OldA, OldB, OldC, B> groupKeyMappingB,
TriFunction<OldA, OldB, OldC, C> groupKeyMappingC,
TriFunction<OldA, OldB, OldC, D> groupKeyMappingD,
TriTuple<OldA, OldB, OldC> tuple) {<FILL_FUNCTION_BODY>}
@Override
protected QuadTupleImpl<A, B, C, D> createOutTuple(Quadruple<A, B, C, D> groupKey) {
return new QuadTupleImpl<>(groupKey.getA(), groupKey.getB(), groupKey.getC(), groupKey.getD(), outputStoreSize);
}
@Override
protected void updateOutTupleToResult(QuadTupleImpl<A, B, C, D> outTuple, Void unused) {
throw new IllegalStateException("Impossible state: collector is null.");
}
}
|
OldA oldA = tuple.getFactA();
OldB oldB = tuple.getFactB();
OldC oldC = tuple.getFactC();
A a = groupKeyMappingA.apply(oldA, oldB, oldC);
B b = groupKeyMappingB.apply(oldA, oldB, oldC);
C c = groupKeyMappingC.apply(oldA, oldB, oldC);
D d = groupKeyMappingD.apply(oldA, oldB, oldC);
return Quadruple.of(a, b, c, d);
| 618
| 144
| 762
|
<methods><variables>private final non-sealed QuadFunction<java.lang.Void,OldA,OldB,OldC,java.lang.Runnable> accumulator
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/tri/TriScorer.java
|
TriScorer
|
impact
|
class TriScorer<A, B, C> extends AbstractScorer<TriTuple<A, B, C>> {
private final TriFunction<A, B, C, UndoScoreImpacter> scoreImpacter;
public TriScorer(String constraintPackage, String constraintName, Score<?> constraintWeight,
TriFunction<A, B, C, UndoScoreImpacter> scoreImpacter, int inputStoreIndex) {
super(constraintPackage, constraintName, constraintWeight, inputStoreIndex);
this.scoreImpacter = scoreImpacter;
}
@Override
protected UndoScoreImpacter impact(TriTuple<A, B, C> tuple) {<FILL_FUNCTION_BODY>}
}
|
try {
return scoreImpacter.apply(tuple.getFactA(), tuple.getFactB(), tuple.getFactC());
} catch (Exception e) {
throw createExceptionOnImpact(tuple, e);
}
| 184
| 63
| 247
|
<methods>public final void insert(TriTuple<A,B,C>) ,public final void retract(TriTuple<A,B,C>) ,public final java.lang.String toString() ,public final void update(TriTuple<A,B,C>) <variables>private final non-sealed java.lang.String constraintId,private final non-sealed Score<?> constraintWeight,private final non-sealed int inputStoreIndex
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/tri/TriTupleImpl.java
|
TriTupleImpl
|
toString
|
class TriTupleImpl<A, B, C> extends AbstractTuple implements TriTuple<A, B, C> {
// Only a tuple's origin node may modify a fact.
public A factA;
public B factB;
public C factC;
public TriTupleImpl(A factA, B factB, C factC, int storeSize) {
super(storeSize);
this.factA = factA;
this.factB = factB;
this.factC = factC;
}
@Override
public A getFactA() {
return factA;
}
@Override
public B getFactB() {
return factB;
}
@Override
public C getFactC() {
return factC;
}
@Override
public String toString() {<FILL_FUNCTION_BODY>}
}
|
return "{" + factA + ", " + factB + ", " + factC + "}";
| 229
| 27
| 256
|
<methods>public final org.optaplanner.constraint.streams.bavet.common.BavetTupleState getState() ,public final Value_ getStore(int) ,public Value_ removeStore(int) ,public final void setState(org.optaplanner.constraint.streams.bavet.common.BavetTupleState) ,public final void setStore(int, java.lang.Object) <variables>public org.optaplanner.constraint.streams.bavet.common.BavetTupleState state,private java.lang.Object store,private final non-sealed boolean storeIsArray
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/uni/BavetBiGroupBridgeUniConstraintStream.java
|
BavetBiGroupBridgeUniConstraintStream
|
buildNode
|
class BavetBiGroupBridgeUniConstraintStream<Solution_, A, NewA, NewB>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final BavetAbstractUniConstraintStream<Solution_, A> parent;
private BavetGroupBiConstraintStream<Solution_, NewA, NewB> groupStream;
private final GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor;
public BavetBiGroupBridgeUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent,
GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
this.nodeConstructor = nodeConstructor;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
public void setGroupStream(BavetGroupBiConstraintStream<Solution_, NewA, NewB> groupStream) {
this.groupStream = groupStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {<FILL_FUNCTION_BODY>}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parent.getTupleSource();
}
}
|
List<? extends ConstraintStream> groupStreamChildList = groupStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), groupStream, groupStreamChildList, this, childStreamList,
constraintFactory.getEnvironmentMode());
| 443
| 66
| 509
|
<methods>public void <init>(BavetConstraintFactory<Solution_>, org.optaplanner.constraint.streams.common.RetrievalSemantics) ,public BavetAbstractUniConstraintStream<Solution_,A> filter(Predicate<A>) ,public UniConstraintStream<ResultA_> flattenLast(Function<A,Iterable<ResultA_>>) ,public List<BavetAbstractUniConstraintStream<Solution_,A>> getChildStreamList() ,public UniConstraintStream<Result_> groupBy(UniConstraintCollector<A,ResultContainer_,Result_>) ,public BiConstraintStream<ResultA_,ResultB_> groupBy(UniConstraintCollector<A,ResultContainerA_,ResultA_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>) ,public TriConstraintStream<ResultA_,ResultB_,ResultC_> groupBy(UniConstraintCollector<A,ResultContainerA_,ResultA_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_> groupBy(UniConstraintCollector<A,ResultContainerA_,ResultA_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public UniConstraintStream<GroupKey_> groupBy(Function<A,GroupKey_>) ,public TriConstraintStream<GroupKey_,ResultB_,ResultC_> groupBy(Function<A,GroupKey_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_> groupBy(Function<A,GroupKey_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public BiConstraintStream<GroupKey_,Result_> groupBy(Function<A,GroupKey_>, UniConstraintCollector<A,ResultContainer_,Result_>) ,public BiConstraintStream<GroupKeyA_,GroupKeyB_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, UniConstraintCollector<A,ResultContainer_,Result_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, Function<A,GroupKeyC_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, Function<A,GroupKeyC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, Function<A,GroupKeyC_>, Function<A,GroupKeyD_>) ,public final transient UniConstraintStream<A> ifExists(Class<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifExists(UniConstraintStream<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifExistsIncludingNullVars(Class<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifNotExists(Class<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifNotExists(UniConstraintStream<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifNotExistsIncludingNullVars(Class<B>, BiJoiner<A,B>[]) ,public UniConstraintBuilder<A,Score_> innerImpact(Score_, ToIntFunction<A>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public UniConstraintBuilder<A,Score_> innerImpact(Score_, ToLongFunction<A>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public UniConstraintBuilder<A,Score_> innerImpact(Score_, Function<A,java.math.BigDecimal>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public final transient BiConstraintStream<A,B> join(UniConstraintStream<B>, BiJoiner<A,B>[]) ,public final BiConstraintStream<A,B> join(UniConstraintStream<B>, BiJoinerComber<A,B>) ,public UniConstraintStream<ResultA_> map(Function<A,ResultA_>) ,public Stream_ shareAndAddChild(Stream_) <variables>protected final List<BavetAbstractUniConstraintStream<Solution_,A>> childStreamList
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/uni/BavetFilterUniConstraintStream.java
|
BavetFilterUniConstraintStream
|
toString
|
class BavetFilterUniConstraintStream<Solution_, A> extends BavetAbstractUniConstraintStream<Solution_, A> {
private final BavetAbstractUniConstraintStream<Solution_, A> parent;
private final Predicate<A> predicate;
public BavetFilterUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent, Predicate<A> predicate) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
this.predicate = predicate;
if (predicate == null) {
throw new IllegalArgumentException("The predicate (null) cannot be null.");
}
}
@Override
public boolean guaranteesDistinct() {
return parent.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parent.getTupleSource();
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
buildHelper.<UniTuple<A>> putInsertUpdateRetract(this, childStreamList,
tupleLifecycle -> new ConditionalUniTupleLifecycle<>(predicate, tupleLifecycle));
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public int hashCode() {
return Objects.hash(parent, predicate);
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
} else if (o instanceof BavetFilterUniConstraintStream) {
BavetFilterUniConstraintStream<?, ?> other = (BavetFilterUniConstraintStream<?, ?>) o;
return parent == other.parent
&& predicate == other.predicate;
} else {
return false;
}
}
@Override
public String toString() {<FILL_FUNCTION_BODY>}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
return "Filter() with " + childStreamList.size() + " children";
| 634
| 22
| 656
|
<methods>public void <init>(BavetConstraintFactory<Solution_>, org.optaplanner.constraint.streams.common.RetrievalSemantics) ,public BavetAbstractUniConstraintStream<Solution_,A> filter(Predicate<A>) ,public UniConstraintStream<ResultA_> flattenLast(Function<A,Iterable<ResultA_>>) ,public List<BavetAbstractUniConstraintStream<Solution_,A>> getChildStreamList() ,public UniConstraintStream<Result_> groupBy(UniConstraintCollector<A,ResultContainer_,Result_>) ,public BiConstraintStream<ResultA_,ResultB_> groupBy(UniConstraintCollector<A,ResultContainerA_,ResultA_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>) ,public TriConstraintStream<ResultA_,ResultB_,ResultC_> groupBy(UniConstraintCollector<A,ResultContainerA_,ResultA_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_> groupBy(UniConstraintCollector<A,ResultContainerA_,ResultA_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public UniConstraintStream<GroupKey_> groupBy(Function<A,GroupKey_>) ,public TriConstraintStream<GroupKey_,ResultB_,ResultC_> groupBy(Function<A,GroupKey_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_> groupBy(Function<A,GroupKey_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public BiConstraintStream<GroupKey_,Result_> groupBy(Function<A,GroupKey_>, UniConstraintCollector<A,ResultContainer_,Result_>) ,public BiConstraintStream<GroupKeyA_,GroupKeyB_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, UniConstraintCollector<A,ResultContainer_,Result_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, Function<A,GroupKeyC_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, Function<A,GroupKeyC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, Function<A,GroupKeyC_>, Function<A,GroupKeyD_>) ,public final transient UniConstraintStream<A> ifExists(Class<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifExists(UniConstraintStream<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifExistsIncludingNullVars(Class<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifNotExists(Class<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifNotExists(UniConstraintStream<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifNotExistsIncludingNullVars(Class<B>, BiJoiner<A,B>[]) ,public UniConstraintBuilder<A,Score_> innerImpact(Score_, ToIntFunction<A>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public UniConstraintBuilder<A,Score_> innerImpact(Score_, ToLongFunction<A>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public UniConstraintBuilder<A,Score_> innerImpact(Score_, Function<A,java.math.BigDecimal>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public final transient BiConstraintStream<A,B> join(UniConstraintStream<B>, BiJoiner<A,B>[]) ,public final BiConstraintStream<A,B> join(UniConstraintStream<B>, BiJoinerComber<A,B>) ,public UniConstraintStream<ResultA_> map(Function<A,ResultA_>) ,public Stream_ shareAndAddChild(Stream_) <variables>protected final List<BavetAbstractUniConstraintStream<Solution_,A>> childStreamList
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/uni/BavetFlattenLastBridgeUniConstraintStream.java
|
BavetFlattenLastBridgeUniConstraintStream
|
buildNode
|
class BavetFlattenLastBridgeUniConstraintStream<Solution_, A, NewA>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final BavetAbstractUniConstraintStream<Solution_, A> parent;
private final Function<A, Iterable<NewA>> mappingFunction;
private BavetFlattenLastUniConstraintStream<Solution_, NewA> flattenLastStream;
public BavetFlattenLastBridgeUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent,
Function<A, Iterable<NewA>> mappingFunction) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
this.mappingFunction = mappingFunction;
}
@Override
public boolean guaranteesDistinct() {
return false;
}
public void setFlattenLastStream(BavetFlattenLastUniConstraintStream<Solution_, NewA> flattenLastStream) {
this.flattenLastStream = flattenLastStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parent.getTupleSource();
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {<FILL_FUNCTION_BODY>}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
// TODO
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
if (!childStreamList.isEmpty()) {
throw new IllegalStateException("Impossible state: the stream (" + this
+ ") has an non-empty childStreamList (" + childStreamList + ") but it's a flattenLast bridge.");
}
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(flattenLastStream);
AbstractFlattenLastNode<UniTuple<A>, UniTuple<NewA>, A, NewA> node = new FlattenLastUniNode<>(
inputStoreIndex, mappingFunction,
buildHelper.getAggregatedTupleLifecycle(flattenLastStream.getChildStreamList()),
outputStoreSize);
buildHelper.addNode(node, this);
| 500
| 203
| 703
|
<methods>public void <init>(BavetConstraintFactory<Solution_>, org.optaplanner.constraint.streams.common.RetrievalSemantics) ,public BavetAbstractUniConstraintStream<Solution_,A> filter(Predicate<A>) ,public UniConstraintStream<ResultA_> flattenLast(Function<A,Iterable<ResultA_>>) ,public List<BavetAbstractUniConstraintStream<Solution_,A>> getChildStreamList() ,public UniConstraintStream<Result_> groupBy(UniConstraintCollector<A,ResultContainer_,Result_>) ,public BiConstraintStream<ResultA_,ResultB_> groupBy(UniConstraintCollector<A,ResultContainerA_,ResultA_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>) ,public TriConstraintStream<ResultA_,ResultB_,ResultC_> groupBy(UniConstraintCollector<A,ResultContainerA_,ResultA_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_> groupBy(UniConstraintCollector<A,ResultContainerA_,ResultA_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public UniConstraintStream<GroupKey_> groupBy(Function<A,GroupKey_>) ,public TriConstraintStream<GroupKey_,ResultB_,ResultC_> groupBy(Function<A,GroupKey_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_> groupBy(Function<A,GroupKey_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public BiConstraintStream<GroupKey_,Result_> groupBy(Function<A,GroupKey_>, UniConstraintCollector<A,ResultContainer_,Result_>) ,public BiConstraintStream<GroupKeyA_,GroupKeyB_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, UniConstraintCollector<A,ResultContainer_,Result_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, Function<A,GroupKeyC_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, Function<A,GroupKeyC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, Function<A,GroupKeyC_>, Function<A,GroupKeyD_>) ,public final transient UniConstraintStream<A> ifExists(Class<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifExists(UniConstraintStream<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifExistsIncludingNullVars(Class<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifNotExists(Class<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifNotExists(UniConstraintStream<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifNotExistsIncludingNullVars(Class<B>, BiJoiner<A,B>[]) ,public UniConstraintBuilder<A,Score_> innerImpact(Score_, ToIntFunction<A>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public UniConstraintBuilder<A,Score_> innerImpact(Score_, ToLongFunction<A>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public UniConstraintBuilder<A,Score_> innerImpact(Score_, Function<A,java.math.BigDecimal>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public final transient BiConstraintStream<A,B> join(UniConstraintStream<B>, BiJoiner<A,B>[]) ,public final BiConstraintStream<A,B> join(UniConstraintStream<B>, BiJoinerComber<A,B>) ,public UniConstraintStream<ResultA_> map(Function<A,ResultA_>) ,public Stream_ shareAndAddChild(Stream_) <variables>protected final List<BavetAbstractUniConstraintStream<Solution_,A>> childStreamList
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/uni/BavetFlattenLastUniConstraintStream.java
|
BavetFlattenLastUniConstraintStream
|
toString
|
class BavetFlattenLastUniConstraintStream<Solution_, A>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final BavetAbstractConstraintStream<Solution_> parent;
public BavetFlattenLastUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractConstraintStream<Solution_> parent) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
}
@Override
public boolean guaranteesDistinct() {
return false;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
// Do nothing. BavetFlattenLastBridgeUniConstraintStream, etc build everything.
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
// TODO
@Override
public String toString() {<FILL_FUNCTION_BODY>}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
return "FlattenLast() with " + childStreamList.size() + " children";
| 368
| 25
| 393
|
<methods>public void <init>(BavetConstraintFactory<Solution_>, org.optaplanner.constraint.streams.common.RetrievalSemantics) ,public BavetAbstractUniConstraintStream<Solution_,A> filter(Predicate<A>) ,public UniConstraintStream<ResultA_> flattenLast(Function<A,Iterable<ResultA_>>) ,public List<BavetAbstractUniConstraintStream<Solution_,A>> getChildStreamList() ,public UniConstraintStream<Result_> groupBy(UniConstraintCollector<A,ResultContainer_,Result_>) ,public BiConstraintStream<ResultA_,ResultB_> groupBy(UniConstraintCollector<A,ResultContainerA_,ResultA_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>) ,public TriConstraintStream<ResultA_,ResultB_,ResultC_> groupBy(UniConstraintCollector<A,ResultContainerA_,ResultA_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_> groupBy(UniConstraintCollector<A,ResultContainerA_,ResultA_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public UniConstraintStream<GroupKey_> groupBy(Function<A,GroupKey_>) ,public TriConstraintStream<GroupKey_,ResultB_,ResultC_> groupBy(Function<A,GroupKey_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_> groupBy(Function<A,GroupKey_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public BiConstraintStream<GroupKey_,Result_> groupBy(Function<A,GroupKey_>, UniConstraintCollector<A,ResultContainer_,Result_>) ,public BiConstraintStream<GroupKeyA_,GroupKeyB_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, UniConstraintCollector<A,ResultContainer_,Result_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, Function<A,GroupKeyC_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, Function<A,GroupKeyC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, Function<A,GroupKeyC_>, Function<A,GroupKeyD_>) ,public final transient UniConstraintStream<A> ifExists(Class<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifExists(UniConstraintStream<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifExistsIncludingNullVars(Class<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifNotExists(Class<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifNotExists(UniConstraintStream<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifNotExistsIncludingNullVars(Class<B>, BiJoiner<A,B>[]) ,public UniConstraintBuilder<A,Score_> innerImpact(Score_, ToIntFunction<A>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public UniConstraintBuilder<A,Score_> innerImpact(Score_, ToLongFunction<A>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public UniConstraintBuilder<A,Score_> innerImpact(Score_, Function<A,java.math.BigDecimal>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public final transient BiConstraintStream<A,B> join(UniConstraintStream<B>, BiJoiner<A,B>[]) ,public final BiConstraintStream<A,B> join(UniConstraintStream<B>, BiJoinerComber<A,B>) ,public UniConstraintStream<ResultA_> map(Function<A,ResultA_>) ,public Stream_ shareAndAddChild(Stream_) <variables>protected final List<BavetAbstractUniConstraintStream<Solution_,A>> childStreamList
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/uni/BavetForEachUniConstraintStream.java
|
BavetForEachUniConstraintStream
|
toString
|
class BavetForEachUniConstraintStream<Solution_, A> extends BavetAbstractUniConstraintStream<Solution_, A> {
private final Class<A> forEachClass;
public BavetForEachUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory, Class<A> forEachClass,
RetrievalSemantics retrievalSemantics) {
super(constraintFactory, retrievalSemantics);
this.forEachClass = forEachClass;
if (forEachClass == null) {
throw new IllegalArgumentException("The forEachClass (null) cannot be null.");
}
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
TupleLifecycle<UniTuple<A>> tupleLifecycle = buildHelper.getAggregatedTupleLifecycle(childStreamList);
int outputStoreSize = buildHelper.extractTupleStoreSize(this);
buildHelper.addNode(new ForEachUniNode<>(forEachClass, tupleLifecycle, outputStoreSize));
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public int hashCode() {
return forEachClass.hashCode();
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
} else if (o instanceof BavetForEachUniConstraintStream) {
BavetForEachUniConstraintStream<?, ?> other = (BavetForEachUniConstraintStream<?, ?>) o;
return forEachClass.equals(other.forEachClass);
} else {
return false;
}
}
@Override
public String toString() {<FILL_FUNCTION_BODY>}
// ************************************************************************
// Getters/setters
// ************************************************************************
public Class<A> getForEachClass() {
return forEachClass;
}
}
|
return "ForEach(" + forEachClass.getSimpleName() + ") with " + childStreamList.size() + " children";
| 598
| 34
| 632
|
<methods>public void <init>(BavetConstraintFactory<Solution_>, org.optaplanner.constraint.streams.common.RetrievalSemantics) ,public BavetAbstractUniConstraintStream<Solution_,A> filter(Predicate<A>) ,public UniConstraintStream<ResultA_> flattenLast(Function<A,Iterable<ResultA_>>) ,public List<BavetAbstractUniConstraintStream<Solution_,A>> getChildStreamList() ,public UniConstraintStream<Result_> groupBy(UniConstraintCollector<A,ResultContainer_,Result_>) ,public BiConstraintStream<ResultA_,ResultB_> groupBy(UniConstraintCollector<A,ResultContainerA_,ResultA_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>) ,public TriConstraintStream<ResultA_,ResultB_,ResultC_> groupBy(UniConstraintCollector<A,ResultContainerA_,ResultA_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_> groupBy(UniConstraintCollector<A,ResultContainerA_,ResultA_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public UniConstraintStream<GroupKey_> groupBy(Function<A,GroupKey_>) ,public TriConstraintStream<GroupKey_,ResultB_,ResultC_> groupBy(Function<A,GroupKey_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_> groupBy(Function<A,GroupKey_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public BiConstraintStream<GroupKey_,Result_> groupBy(Function<A,GroupKey_>, UniConstraintCollector<A,ResultContainer_,Result_>) ,public BiConstraintStream<GroupKeyA_,GroupKeyB_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, UniConstraintCollector<A,ResultContainer_,Result_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, Function<A,GroupKeyC_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, Function<A,GroupKeyC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, Function<A,GroupKeyC_>, Function<A,GroupKeyD_>) ,public final transient UniConstraintStream<A> ifExists(Class<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifExists(UniConstraintStream<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifExistsIncludingNullVars(Class<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifNotExists(Class<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifNotExists(UniConstraintStream<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifNotExistsIncludingNullVars(Class<B>, BiJoiner<A,B>[]) ,public UniConstraintBuilder<A,Score_> innerImpact(Score_, ToIntFunction<A>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public UniConstraintBuilder<A,Score_> innerImpact(Score_, ToLongFunction<A>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public UniConstraintBuilder<A,Score_> innerImpact(Score_, Function<A,java.math.BigDecimal>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public final transient BiConstraintStream<A,B> join(UniConstraintStream<B>, BiJoiner<A,B>[]) ,public final BiConstraintStream<A,B> join(UniConstraintStream<B>, BiJoinerComber<A,B>) ,public UniConstraintStream<ResultA_> map(Function<A,ResultA_>) ,public Stream_ shareAndAddChild(Stream_) <variables>protected final List<BavetAbstractUniConstraintStream<Solution_,A>> childStreamList
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/uni/BavetGroupUniConstraintStream.java
|
BavetGroupUniConstraintStream
|
toString
|
class BavetGroupUniConstraintStream<Solution_, A>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final BavetAbstractConstraintStream<Solution_> parent;
public BavetGroupUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractConstraintStream<Solution_> parent) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
// Do nothing. BavetGroupBridgeUniConstraintStream, etc build everything.
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
// TODO
@Override
public String toString() {<FILL_FUNCTION_BODY>}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
return "Group() with " + childStreamList.size() + " children";
| 359
| 22
| 381
|
<methods>public void <init>(BavetConstraintFactory<Solution_>, org.optaplanner.constraint.streams.common.RetrievalSemantics) ,public BavetAbstractUniConstraintStream<Solution_,A> filter(Predicate<A>) ,public UniConstraintStream<ResultA_> flattenLast(Function<A,Iterable<ResultA_>>) ,public List<BavetAbstractUniConstraintStream<Solution_,A>> getChildStreamList() ,public UniConstraintStream<Result_> groupBy(UniConstraintCollector<A,ResultContainer_,Result_>) ,public BiConstraintStream<ResultA_,ResultB_> groupBy(UniConstraintCollector<A,ResultContainerA_,ResultA_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>) ,public TriConstraintStream<ResultA_,ResultB_,ResultC_> groupBy(UniConstraintCollector<A,ResultContainerA_,ResultA_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_> groupBy(UniConstraintCollector<A,ResultContainerA_,ResultA_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public UniConstraintStream<GroupKey_> groupBy(Function<A,GroupKey_>) ,public TriConstraintStream<GroupKey_,ResultB_,ResultC_> groupBy(Function<A,GroupKey_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_> groupBy(Function<A,GroupKey_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public BiConstraintStream<GroupKey_,Result_> groupBy(Function<A,GroupKey_>, UniConstraintCollector<A,ResultContainer_,Result_>) ,public BiConstraintStream<GroupKeyA_,GroupKeyB_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, UniConstraintCollector<A,ResultContainer_,Result_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, Function<A,GroupKeyC_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, Function<A,GroupKeyC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, Function<A,GroupKeyC_>, Function<A,GroupKeyD_>) ,public final transient UniConstraintStream<A> ifExists(Class<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifExists(UniConstraintStream<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifExistsIncludingNullVars(Class<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifNotExists(Class<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifNotExists(UniConstraintStream<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifNotExistsIncludingNullVars(Class<B>, BiJoiner<A,B>[]) ,public UniConstraintBuilder<A,Score_> innerImpact(Score_, ToIntFunction<A>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public UniConstraintBuilder<A,Score_> innerImpact(Score_, ToLongFunction<A>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public UniConstraintBuilder<A,Score_> innerImpact(Score_, Function<A,java.math.BigDecimal>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public final transient BiConstraintStream<A,B> join(UniConstraintStream<B>, BiJoiner<A,B>[]) ,public final BiConstraintStream<A,B> join(UniConstraintStream<B>, BiJoinerComber<A,B>) ,public UniConstraintStream<ResultA_> map(Function<A,ResultA_>) ,public Stream_ shareAndAddChild(Stream_) <variables>protected final List<BavetAbstractUniConstraintStream<Solution_,A>> childStreamList
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/uni/BavetMapUniConstraintStream.java
|
BavetMapUniConstraintStream
|
toString
|
class BavetMapUniConstraintStream<Solution_, A>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final BavetAbstractConstraintStream<Solution_> parent;
public BavetMapUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractConstraintStream<Solution_> parent) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
}
@Override
public boolean guaranteesDistinct() {
return false;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
// Do nothing. BavetMapBridgeUniConstraintStream, etc build everything.
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
// TODO
@Override
public String toString() {<FILL_FUNCTION_BODY>}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
return "Map() with " + childStreamList.size() + " children";
| 359
| 22
| 381
|
<methods>public void <init>(BavetConstraintFactory<Solution_>, org.optaplanner.constraint.streams.common.RetrievalSemantics) ,public BavetAbstractUniConstraintStream<Solution_,A> filter(Predicate<A>) ,public UniConstraintStream<ResultA_> flattenLast(Function<A,Iterable<ResultA_>>) ,public List<BavetAbstractUniConstraintStream<Solution_,A>> getChildStreamList() ,public UniConstraintStream<Result_> groupBy(UniConstraintCollector<A,ResultContainer_,Result_>) ,public BiConstraintStream<ResultA_,ResultB_> groupBy(UniConstraintCollector<A,ResultContainerA_,ResultA_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>) ,public TriConstraintStream<ResultA_,ResultB_,ResultC_> groupBy(UniConstraintCollector<A,ResultContainerA_,ResultA_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_> groupBy(UniConstraintCollector<A,ResultContainerA_,ResultA_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public UniConstraintStream<GroupKey_> groupBy(Function<A,GroupKey_>) ,public TriConstraintStream<GroupKey_,ResultB_,ResultC_> groupBy(Function<A,GroupKey_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_> groupBy(Function<A,GroupKey_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public BiConstraintStream<GroupKey_,Result_> groupBy(Function<A,GroupKey_>, UniConstraintCollector<A,ResultContainer_,Result_>) ,public BiConstraintStream<GroupKeyA_,GroupKeyB_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, UniConstraintCollector<A,ResultContainer_,Result_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, Function<A,GroupKeyC_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, Function<A,GroupKeyC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, Function<A,GroupKeyC_>, Function<A,GroupKeyD_>) ,public final transient UniConstraintStream<A> ifExists(Class<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifExists(UniConstraintStream<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifExistsIncludingNullVars(Class<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifNotExists(Class<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifNotExists(UniConstraintStream<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifNotExistsIncludingNullVars(Class<B>, BiJoiner<A,B>[]) ,public UniConstraintBuilder<A,Score_> innerImpact(Score_, ToIntFunction<A>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public UniConstraintBuilder<A,Score_> innerImpact(Score_, ToLongFunction<A>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public UniConstraintBuilder<A,Score_> innerImpact(Score_, Function<A,java.math.BigDecimal>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public final transient BiConstraintStream<A,B> join(UniConstraintStream<B>, BiJoiner<A,B>[]) ,public final BiConstraintStream<A,B> join(UniConstraintStream<B>, BiJoinerComber<A,B>) ,public UniConstraintStream<ResultA_> map(Function<A,ResultA_>) ,public Stream_ shareAndAddChild(Stream_) <variables>protected final List<BavetAbstractUniConstraintStream<Solution_,A>> childStreamList
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/uni/BavetScoringUniConstraintStream.java
|
BavetScoringUniConstraintStream
|
buildNode
|
class BavetScoringUniConstraintStream<Solution_, A>
extends BavetAbstractUniConstraintStream<Solution_, A>
implements BavetScoringConstraintStream<Solution_> {
private final BavetAbstractUniConstraintStream<Solution_, A> parent;
private final boolean noMatchWeigher;
private final ToIntFunction<A> intMatchWeigher;
private final ToLongFunction<A> longMatchWeigher;
private final Function<A, BigDecimal> bigDecimalMatchWeigher;
private BavetConstraint<Solution_> constraint;
public BavetScoringUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent,
ToIntFunction<A> intMatchWeigher) {
this(constraintFactory, parent, false, intMatchWeigher, null, null);
if (intMatchWeigher == null) {
throw new IllegalArgumentException("The matchWeigher (null) cannot be null.");
}
}
public BavetScoringUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent,
ToLongFunction<A> longMatchWeigher) {
this(constraintFactory, parent, false, null, longMatchWeigher, null);
if (longMatchWeigher == null) {
throw new IllegalArgumentException("The matchWeigher (null) cannot be null.");
}
}
public BavetScoringUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent,
Function<A, BigDecimal> bigDecimalMatchWeigher) {
this(constraintFactory, parent, false, null, null, bigDecimalMatchWeigher);
if (bigDecimalMatchWeigher == null) {
throw new IllegalArgumentException("The matchWeigher (null) cannot be null.");
}
}
private BavetScoringUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent,
boolean noMatchWeigher, ToIntFunction<A> intMatchWeigher, ToLongFunction<A> longMatchWeigher,
Function<A, BigDecimal> bigDecimalMatchWeigher) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
this.noMatchWeigher = noMatchWeigher;
this.intMatchWeigher = intMatchWeigher;
this.longMatchWeigher = longMatchWeigher;
this.bigDecimalMatchWeigher = bigDecimalMatchWeigher;
}
@Override
public void setConstraint(BavetConstraint<Solution_> constraint) {
this.constraint = constraint;
}
@Override
public boolean guaranteesDistinct() {
return parent.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parent.getTupleSource();
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {<FILL_FUNCTION_BODY>}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
// No node sharing
@Override
public String toString() {
return "Scoring(" + constraint.getConstraintName() + ")";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
if (!childStreamList.isEmpty()) {
throw new IllegalStateException("Impossible state: the stream (" + this
+ ") has an non-empty childStreamList (" + childStreamList + ") but it's an endpoint.");
}
Score_ constraintWeight = buildHelper.getConstraintWeight(constraint);
WeightedScoreImpacter<Score_, ?> weightedScoreImpacter =
buildHelper.getScoreInliner().buildWeightedScoreImpacter(constraint, constraintWeight);
boolean constraintMatchEnabled = buildHelper.getScoreInliner().isConstraintMatchEnabled();
Function<A, UndoScoreImpacter> scoreImpacter;
if (intMatchWeigher != null) {
if (constraintMatchEnabled) {
scoreImpacter = a -> {
int matchWeight = intMatchWeigher.applyAsInt(a);
constraint.assertCorrectImpact(matchWeight);
JustificationsSupplier justificationsSupplier =
of(constraint, constraint.getJustificationMapping(), constraint.getIndictedObjectsMapping(), a);
return weightedScoreImpacter.impactScore(matchWeight, justificationsSupplier);
};
} else {
scoreImpacter = a -> {
int matchWeight = intMatchWeigher.applyAsInt(a);
constraint.assertCorrectImpact(matchWeight);
return weightedScoreImpacter.impactScore(matchWeight, null);
};
}
} else if (longMatchWeigher != null) {
if (constraintMatchEnabled) {
scoreImpacter = a -> {
long matchWeight = longMatchWeigher.applyAsLong(a);
constraint.assertCorrectImpact(matchWeight);
JustificationsSupplier justificationsSupplier =
of(constraint, constraint.getJustificationMapping(), constraint.getIndictedObjectsMapping(), a);
return weightedScoreImpacter.impactScore(matchWeight, justificationsSupplier);
};
} else {
scoreImpacter = a -> {
long matchWeight = longMatchWeigher.applyAsLong(a);
constraint.assertCorrectImpact(matchWeight);
return weightedScoreImpacter.impactScore(matchWeight, null);
};
}
} else if (bigDecimalMatchWeigher != null) {
if (constraintMatchEnabled) {
scoreImpacter = a -> {
BigDecimal matchWeight = bigDecimalMatchWeigher.apply(a);
constraint.assertCorrectImpact(matchWeight);
JustificationsSupplier justificationsSupplier =
of(constraint, constraint.getJustificationMapping(), constraint.getIndictedObjectsMapping(), a);
return weightedScoreImpacter.impactScore(matchWeight, justificationsSupplier);
};
} else {
scoreImpacter = a -> {
BigDecimal matchWeight = bigDecimalMatchWeigher.apply(a);
constraint.assertCorrectImpact(matchWeight);
return weightedScoreImpacter.impactScore(matchWeight, null);
};
}
} else if (noMatchWeigher) {
if (constraintMatchEnabled) {
scoreImpacter = a -> {
JustificationsSupplier justificationsSupplier =
of(constraint, constraint.getJustificationMapping(), constraint.getIndictedObjectsMapping(), a);
return weightedScoreImpacter.impactScore(1, justificationsSupplier);
};
} else {
scoreImpacter = a -> weightedScoreImpacter.impactScore(1, null);
}
} else {
throw new IllegalStateException("Impossible state: neither of the supported match weighers provided.");
}
UniScorer<A> scorer = new UniScorer<>(constraint.getConstraintPackage(), constraint.getConstraintName(),
constraintWeight, scoreImpacter, buildHelper.reserveTupleStoreIndex(parent.getTupleSource()));
buildHelper.putInsertUpdateRetract(this, scorer);
| 1,020
| 983
| 2,003
|
<methods>public void <init>(BavetConstraintFactory<Solution_>, org.optaplanner.constraint.streams.common.RetrievalSemantics) ,public BavetAbstractUniConstraintStream<Solution_,A> filter(Predicate<A>) ,public UniConstraintStream<ResultA_> flattenLast(Function<A,Iterable<ResultA_>>) ,public List<BavetAbstractUniConstraintStream<Solution_,A>> getChildStreamList() ,public UniConstraintStream<Result_> groupBy(UniConstraintCollector<A,ResultContainer_,Result_>) ,public BiConstraintStream<ResultA_,ResultB_> groupBy(UniConstraintCollector<A,ResultContainerA_,ResultA_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>) ,public TriConstraintStream<ResultA_,ResultB_,ResultC_> groupBy(UniConstraintCollector<A,ResultContainerA_,ResultA_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_> groupBy(UniConstraintCollector<A,ResultContainerA_,ResultA_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public UniConstraintStream<GroupKey_> groupBy(Function<A,GroupKey_>) ,public TriConstraintStream<GroupKey_,ResultB_,ResultC_> groupBy(Function<A,GroupKey_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_> groupBy(Function<A,GroupKey_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public BiConstraintStream<GroupKey_,Result_> groupBy(Function<A,GroupKey_>, UniConstraintCollector<A,ResultContainer_,Result_>) ,public BiConstraintStream<GroupKeyA_,GroupKeyB_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, UniConstraintCollector<A,ResultContainer_,Result_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, Function<A,GroupKeyC_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, Function<A,GroupKeyC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, Function<A,GroupKeyC_>, Function<A,GroupKeyD_>) ,public final transient UniConstraintStream<A> ifExists(Class<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifExists(UniConstraintStream<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifExistsIncludingNullVars(Class<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifNotExists(Class<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifNotExists(UniConstraintStream<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifNotExistsIncludingNullVars(Class<B>, BiJoiner<A,B>[]) ,public UniConstraintBuilder<A,Score_> innerImpact(Score_, ToIntFunction<A>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public UniConstraintBuilder<A,Score_> innerImpact(Score_, ToLongFunction<A>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public UniConstraintBuilder<A,Score_> innerImpact(Score_, Function<A,java.math.BigDecimal>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public final transient BiConstraintStream<A,B> join(UniConstraintStream<B>, BiJoiner<A,B>[]) ,public final BiConstraintStream<A,B> join(UniConstraintStream<B>, BiJoinerComber<A,B>) ,public UniConstraintStream<ResultA_> map(Function<A,ResultA_>) ,public Stream_ shareAndAddChild(Stream_) <variables>protected final List<BavetAbstractUniConstraintStream<Solution_,A>> childStreamList
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/uni/BavetUniGroupBridgeUniConstraintStream.java
|
BavetUniGroupBridgeUniConstraintStream
|
buildNode
|
class BavetUniGroupBridgeUniConstraintStream<Solution_, A, NewA>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final BavetAbstractUniConstraintStream<Solution_, A> parent;
private BavetGroupUniConstraintStream<Solution_, NewA> groupStream;
private final GroupNodeConstructor<UniTuple<NewA>> nodeConstructor;
public BavetUniGroupBridgeUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent, GroupNodeConstructor<UniTuple<NewA>> nodeConstructor) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
this.nodeConstructor = nodeConstructor;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
public void setGroupStream(BavetGroupUniConstraintStream<Solution_, NewA> groupStream) {
this.groupStream = groupStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {<FILL_FUNCTION_BODY>}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parent.getTupleSource();
}
}
|
List<? extends ConstraintStream> groupStreamChildList = groupStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), groupStream, groupStreamChildList, this, childStreamList,
constraintFactory.getEnvironmentMode());
| 432
| 66
| 498
|
<methods>public void <init>(BavetConstraintFactory<Solution_>, org.optaplanner.constraint.streams.common.RetrievalSemantics) ,public BavetAbstractUniConstraintStream<Solution_,A> filter(Predicate<A>) ,public UniConstraintStream<ResultA_> flattenLast(Function<A,Iterable<ResultA_>>) ,public List<BavetAbstractUniConstraintStream<Solution_,A>> getChildStreamList() ,public UniConstraintStream<Result_> groupBy(UniConstraintCollector<A,ResultContainer_,Result_>) ,public BiConstraintStream<ResultA_,ResultB_> groupBy(UniConstraintCollector<A,ResultContainerA_,ResultA_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>) ,public TriConstraintStream<ResultA_,ResultB_,ResultC_> groupBy(UniConstraintCollector<A,ResultContainerA_,ResultA_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_> groupBy(UniConstraintCollector<A,ResultContainerA_,ResultA_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public UniConstraintStream<GroupKey_> groupBy(Function<A,GroupKey_>) ,public TriConstraintStream<GroupKey_,ResultB_,ResultC_> groupBy(Function<A,GroupKey_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_> groupBy(Function<A,GroupKey_>, UniConstraintCollector<A,ResultContainerB_,ResultB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public BiConstraintStream<GroupKey_,Result_> groupBy(Function<A,GroupKey_>, UniConstraintCollector<A,ResultContainer_,Result_>) ,public BiConstraintStream<GroupKeyA_,GroupKeyB_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, UniConstraintCollector<A,ResultContainer_,Result_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, UniConstraintCollector<A,ResultContainerC_,ResultC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, Function<A,GroupKeyC_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, Function<A,GroupKeyC_>, UniConstraintCollector<A,ResultContainerD_,ResultD_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> groupBy(Function<A,GroupKeyA_>, Function<A,GroupKeyB_>, Function<A,GroupKeyC_>, Function<A,GroupKeyD_>) ,public final transient UniConstraintStream<A> ifExists(Class<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifExists(UniConstraintStream<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifExistsIncludingNullVars(Class<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifNotExists(Class<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifNotExists(UniConstraintStream<B>, BiJoiner<A,B>[]) ,public final transient UniConstraintStream<A> ifNotExistsIncludingNullVars(Class<B>, BiJoiner<A,B>[]) ,public UniConstraintBuilder<A,Score_> innerImpact(Score_, ToIntFunction<A>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public UniConstraintBuilder<A,Score_> innerImpact(Score_, ToLongFunction<A>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public UniConstraintBuilder<A,Score_> innerImpact(Score_, Function<A,java.math.BigDecimal>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public final transient BiConstraintStream<A,B> join(UniConstraintStream<B>, BiJoiner<A,B>[]) ,public final BiConstraintStream<A,B> join(UniConstraintStream<B>, BiJoinerComber<A,B>) ,public UniConstraintStream<ResultA_> map(Function<A,ResultA_>) ,public Stream_ shareAndAddChild(Stream_) <variables>protected final List<BavetAbstractUniConstraintStream<Solution_,A>> childStreamList
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/uni/Group0Mapping3CollectorUniNode.java
|
Group0Mapping3CollectorUniNode
|
mergeCollectors
|
class Group0Mapping3CollectorUniNode<OldA, A, B, C, ResultContainerA_, ResultContainerB_, ResultContainerC_>
extends AbstractGroupUniNode<OldA, TriTuple<A, B, C>, TriTupleImpl<A, B, C>, Void, Object, Triple<A, B, C>> {
private final int outputStoreSize;
public Group0Mapping3CollectorUniNode(int groupStoreIndex, int undoStoreIndex,
UniConstraintCollector<OldA, ResultContainerA_, A> collectorA,
UniConstraintCollector<OldA, ResultContainerB_, B> collectorB,
UniConstraintCollector<OldA, ResultContainerC_, C> collectorC,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex, null, mergeCollectors(collectorA, collectorB, collectorC),
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
static <OldA, A, B, C, ResultContainerA_, ResultContainerB_, ResultContainerC_>
UniConstraintCollector<OldA, Object, Triple<A, B, C>> mergeCollectors(
UniConstraintCollector<OldA, ResultContainerA_, A> collectorA,
UniConstraintCollector<OldA, ResultContainerB_, B> collectorB,
UniConstraintCollector<OldA, ResultContainerC_, C> collectorC) {<FILL_FUNCTION_BODY>}
@Override
protected TriTupleImpl<A, B, C> createOutTuple(Void groupKey) {
return new TriTupleImpl<>(null, null, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(TriTupleImpl<A, B, C> outTuple, Triple<A, B, C> result) {
outTuple.factA = result.getA();
outTuple.factB = result.getB();
outTuple.factC = result.getC();
}
}
|
return (UniConstraintCollector<OldA, Object, Triple<A, B, C>>) ConstraintCollectors.compose(collectorA, collectorB,
collectorC, Triple::of);
| 546
| 53
| 599
|
<methods><variables>private final non-sealed BiFunction<java.lang.Object,OldA,java.lang.Runnable> accumulator
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/uni/Group0Mapping4CollectorUniNode.java
|
Group0Mapping4CollectorUniNode
|
mergeCollectors
|
class Group0Mapping4CollectorUniNode<OldA, A, B, C, D, ResultContainerA_, ResultContainerB_, ResultContainerC_, ResultContainerD_>
extends
AbstractGroupUniNode<OldA, QuadTuple<A, B, C, D>, QuadTupleImpl<A, B, C, D>, Void, Object, Quadruple<A, B, C, D>> {
private final int outputStoreSize;
public Group0Mapping4CollectorUniNode(int groupStoreIndex, int undoStoreIndex,
UniConstraintCollector<OldA, ResultContainerA_, A> collectorA,
UniConstraintCollector<OldA, ResultContainerB_, B> collectorB,
UniConstraintCollector<OldA, ResultContainerC_, C> collectorC,
UniConstraintCollector<OldA, ResultContainerD_, D> collectorD,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle, int outputStoreSize,
EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex, null, mergeCollectors(collectorA, collectorB, collectorC, collectorD),
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
private static <OldA, A, B, C, D, ResultContainerA_, ResultContainerB_, ResultContainerC_, ResultContainerD_>
UniConstraintCollector<OldA, Object, Quadruple<A, B, C, D>> mergeCollectors(
UniConstraintCollector<OldA, ResultContainerA_, A> collectorA,
UniConstraintCollector<OldA, ResultContainerB_, B> collectorB,
UniConstraintCollector<OldA, ResultContainerC_, C> collectorC,
UniConstraintCollector<OldA, ResultContainerD_, D> collectorD) {<FILL_FUNCTION_BODY>}
@Override
protected QuadTupleImpl<A, B, C, D> createOutTuple(Void groupKey) {
return new QuadTupleImpl<>(null, null, null, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(QuadTupleImpl<A, B, C, D> outTuple, Quadruple<A, B, C, D> result) {
outTuple.factA = result.getA();
outTuple.factB = result.getB();
outTuple.factC = result.getC();
outTuple.factD = result.getD();
}
}
|
return (UniConstraintCollector<OldA, Object, Quadruple<A, B, C, D>>) ConstraintCollectors.compose(collectorA,
collectorB, collectorC, collectorD, Quadruple::of);
| 650
| 62
| 712
|
<methods><variables>private final non-sealed BiFunction<java.lang.Object,OldA,java.lang.Runnable> accumulator
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/uni/Group1Mapping3CollectorUniNode.java
|
Group1Mapping3CollectorUniNode
|
updateOutTupleToResult
|
class Group1Mapping3CollectorUniNode<OldA, A, B, C, D, ResultContainerB_, ResultContainerC_, ResultContainerD_>
extends AbstractGroupUniNode<OldA, QuadTuple<A, B, C, D>, QuadTupleImpl<A, B, C, D>, A, Object, Triple<B, C, D>> {
private final int outputStoreSize;
public Group1Mapping3CollectorUniNode(Function<OldA, A> groupKeyMapping, int groupStoreIndex, int undoStoreIndex,
UniConstraintCollector<OldA, ResultContainerB_, B> collectorB,
UniConstraintCollector<OldA, ResultContainerC_, C> collectorC,
UniConstraintCollector<OldA, ResultContainerD_, D> collectorD,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle, int outputStoreSize,
EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex, tuple -> createGroupKey(groupKeyMapping, tuple),
Group0Mapping3CollectorUniNode.mergeCollectors(collectorB, collectorC, collectorD), nextNodesTupleLifecycle,
environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected QuadTupleImpl<A, B, C, D> createOutTuple(A a) {
return new QuadTupleImpl<>(a, null, null, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(QuadTupleImpl<A, B, C, D> outTuple, Triple<B, C, D> result) {<FILL_FUNCTION_BODY>}
}
|
outTuple.factB = result.getA();
outTuple.factC = result.getB();
outTuple.factD = result.getC();
| 440
| 45
| 485
|
<methods><variables>private final non-sealed BiFunction<java.lang.Object,OldA,java.lang.Runnable> accumulator
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/uni/Group3Mapping0CollectorUniNode.java
|
Group3Mapping0CollectorUniNode
|
createGroupKey
|
class Group3Mapping0CollectorUniNode<OldA, A, B, C>
extends AbstractGroupUniNode<OldA, TriTuple<A, B, C>, TriTupleImpl<A, B, C>, Triple<A, B, C>, Void, Void> {
private final int outputStoreSize;
public Group3Mapping0CollectorUniNode(Function<OldA, A> groupKeyMappingA, Function<OldA, B> groupKeyMappingB,
Function<OldA, C> groupKeyMappingC, int groupStoreIndex, TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle,
int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex, tuple -> createGroupKey(groupKeyMappingA, groupKeyMappingB, groupKeyMappingC, tuple),
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
static <A, B, C, OldA> Triple<A, B, C> createGroupKey(Function<OldA, A> groupKeyMappingA,
Function<OldA, B> groupKeyMappingB, Function<OldA, C> groupKeyMappingC, UniTuple<OldA> tuple) {<FILL_FUNCTION_BODY>}
@Override
protected TriTupleImpl<A, B, C> createOutTuple(Triple<A, B, C> groupKey) {
return new TriTupleImpl<>(groupKey.getA(), groupKey.getB(), groupKey.getC(), outputStoreSize);
}
@Override
protected void updateOutTupleToResult(TriTupleImpl<A, B, C> outTuple, Void unused) {
throw new IllegalStateException("Impossible state: collector is null.");
}
}
|
OldA oldA = tuple.getFactA();
A a = groupKeyMappingA.apply(oldA);
B b = groupKeyMappingB.apply(oldA);
C c = groupKeyMappingC.apply(oldA);
return Triple.of(a, b, c);
| 458
| 75
| 533
|
<methods><variables>private final non-sealed BiFunction<java.lang.Void,OldA,java.lang.Runnable> accumulator
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-bavet/src/main/java/org/optaplanner/constraint/streams/bavet/uni/UniScorer.java
|
UniScorer
|
impact
|
class UniScorer<A> extends AbstractScorer<UniTuple<A>> {
private final Function<A, UndoScoreImpacter> scoreImpacter;
public UniScorer(String constraintPackage, String constraintName, Score<?> constraintWeight,
Function<A, UndoScoreImpacter> scoreImpacter, int inputStoreIndex) {
super(constraintPackage, constraintName, constraintWeight, inputStoreIndex);
this.scoreImpacter = scoreImpacter;
}
@Override
protected UndoScoreImpacter impact(UniTuple<A> tuple) {<FILL_FUNCTION_BODY>}
}
|
try {
return scoreImpacter.apply(tuple.getFactA());
} catch (Exception e) {
throw createExceptionOnImpact(tuple, e);
}
| 166
| 51
| 217
|
<methods>public final void insert(UniTuple<A>) ,public final void retract(UniTuple<A>) ,public final java.lang.String toString() ,public final void update(UniTuple<A>) <variables>private final non-sealed java.lang.String constraintId,private final non-sealed Score<?> constraintWeight,private final non-sealed int inputStoreIndex
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-common/src/main/java/org/optaplanner/constraint/streams/common/AbstractConstraintStream.java
|
AbstractConstraintStream
|
buildConstraintWeightExtractor
|
class AbstractConstraintStream<Solution_> implements ConstraintStream {
private final RetrievalSemantics retrievalSemantics;
protected AbstractConstraintStream(RetrievalSemantics retrievalSemantics) {
this.retrievalSemantics = Objects.requireNonNull(retrievalSemantics);
}
public RetrievalSemantics getRetrievalSemantics() {
return retrievalSemantics;
}
// ************************************************************************
// Penalize/reward
// ************************************************************************
protected Function<Solution_, Score<?>> buildConstraintWeightExtractor(String constraintPackage, String constraintName) {<FILL_FUNCTION_BODY>}
protected Function<Solution_, Score<?>> buildConstraintWeightExtractor(String constraintPackage, String constraintName,
Score<?> constraintWeight) {
validateConstraintId(constraintPackage, constraintName);
// Duplicates validation when the session is built, but this fails fast when weights are hard coded
getConstraintFactory().getSolutionDescriptor().validateConstraintWeight(constraintPackage, constraintName,
constraintWeight);
return solution -> constraintWeight;
}
private static void validateConstraintId(String constraintPackage, String constraintName) {
if (constraintPackage == null) {
throw new IllegalStateException("The constraint (" + constraintName
+ ") cannot have a null package (" + constraintPackage + ").");
}
if (constraintName == null) {
throw new IllegalStateException("The constraint of package (" + constraintPackage
+ ") cannot have a null name (" + constraintName + ").");
}
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public abstract InnerConstraintFactory<Solution_, ?> getConstraintFactory();
protected abstract <JustificationMapping_> JustificationMapping_ getDefaultJustificationMapping();
protected abstract <IndictedObjectsMapping_> IndictedObjectsMapping_ getDefaultIndictedObjectsMapping();
}
|
validateConstraintId(constraintPackage, constraintName);
SolutionDescriptor<Solution_> solutionDescriptor = getConstraintFactory().getSolutionDescriptor();
ConstraintConfigurationDescriptor<Solution_> configurationDescriptor = solutionDescriptor
.getConstraintConfigurationDescriptor();
if (configurationDescriptor == null) {
throw new IllegalStateException("The constraint (" + constraintName + ") of package (" + constraintPackage
+ ") does not hard-code a constraint weight"
+ " and there is no @" + ConstraintConfigurationProvider.class.getSimpleName()
+ " on the solution class (" + solutionDescriptor.getSolutionClass() + ").\n"
+ "Maybe add a @" + ConstraintConfiguration.class.getSimpleName() + " class"
+ " or use " + ConstraintStream.class.getSimpleName() + ".penalize()/reward()"
+ " instead of penalizeConfigurable()/rewardConfigurable.");
}
ConstraintWeightDescriptor<Solution_> weightDescriptor = configurationDescriptor
.findConstraintWeightDescriptor(constraintPackage, constraintName);
if (weightDescriptor == null) {
throw new IllegalStateException("The constraint (" + constraintName + ") of package (" + constraintPackage
+ ") does not hard-code a constraint weight"
+ " and there is no such @" + ConstraintWeight.class.getSimpleName()
+ " on the constraintConfigurationClass (" + configurationDescriptor.getConstraintConfigurationClass()
+ ").\n"
+ "Maybe there is a typo in the constraintPackage or constraintName of one of the @"
+ ConstraintWeight.class.getSimpleName() + " members.\n"
+ "Maybe add a @" + ConstraintWeight.class.getSimpleName() + " member for it.");
}
return weightDescriptor.createExtractor();
| 486
| 424
| 910
|
<no_super_class>
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-common/src/main/java/org/optaplanner/constraint/streams/common/InnerConstraintFactory.java
|
InnerConstraintFactory
|
buildConstraints
|
class InnerConstraintFactory<Solution_, Constraint_ extends Constraint> implements ConstraintFactory {
@Override
public <A> UniConstraintStream<A> forEach(Class<A> sourceClass) {
UniConstraintStream<A> stream = forEachIncludingNullVars(sourceClass);
Predicate<A> nullityFilter = getNullityFilter(sourceClass);
return nullityFilter == null ? stream : stream.filter(nullityFilter);
}
public <A> Predicate<A> getNullityFilter(Class<A> fromClass) {
EntityDescriptor<Solution_> entityDescriptor = getSolutionDescriptor().findEntityDescriptor(fromClass);
if (entityDescriptor != null && entityDescriptor.hasAnyGenuineVariables()) {
return (Predicate<A>) entityDescriptor.getHasNoNullVariables();
}
return null;
}
@Override
public <A> BiConstraintStream<A, A> forEachUniquePair(Class<A> sourceClass, BiJoiner<A, A>... joiners) {
BiJoinerComber<A, A> joinerComber = BiJoinerComber.comb(joiners);
joinerComber.addJoiner(buildLessThanId(sourceClass));
return ((InnerUniConstraintStream<A>) forEach(sourceClass))
.join(forEach(sourceClass), joinerComber);
}
private <A> DefaultBiJoiner<A, A> buildLessThanId(Class<A> sourceClass) {
SolutionDescriptor<Solution_> solutionDescriptor = getSolutionDescriptor();
MemberAccessor planningIdMemberAccessor =
ConfigUtils.findPlanningIdMemberAccessor(sourceClass, solutionDescriptor.getMemberAccessorFactory(),
solutionDescriptor.getDomainAccessType());
if (planningIdMemberAccessor == null) {
throw new IllegalArgumentException("The fromClass (" + sourceClass + ") has no member with a @"
+ PlanningId.class.getSimpleName() + " annotation,"
+ " so the pairs cannot be made unique ([A,B] vs [B,A]).");
}
Function<A, Comparable> planningIdGetter = planningIdMemberAccessor.getGetterFunction();
return (DefaultBiJoiner<A, A>) lessThan(planningIdGetter);
}
@Override
public <A> UniConstraintStream<A> from(Class<A> fromClass) {
UniConstraintStream<A> stream = fromUnfiltered(fromClass);
EntityDescriptor<Solution_> entityDescriptor = getSolutionDescriptor().findEntityDescriptor(fromClass);
if (entityDescriptor != null && entityDescriptor.hasAnyGenuineVariables()) {
Predicate<A> predicate = (Predicate<A>) entityDescriptor.getIsInitializedPredicate();
stream = stream.filter(predicate);
}
return stream;
}
@Override
public <A> BiConstraintStream<A, A> fromUniquePair(Class<A> fromClass, BiJoiner<A, A>... joiners) {
BiJoinerComber<A, A> joinerComber = BiJoinerComber.comb(joiners);
joinerComber.addJoiner(buildLessThanId(fromClass));
return ((InnerUniConstraintStream<A>) from(fromClass))
.join(from(fromClass), joinerComber);
}
public <A> void assertValidFromType(Class<A> fromType) {
SolutionDescriptor<Solution_> solutionDescriptor = getSolutionDescriptor();
Set<Class<?>> problemFactOrEntityClassSet = solutionDescriptor.getProblemFactOrEntityClassSet();
/*
* Need to support the following situations:
* 1/ FactType == FromType; querying for the declared type.
* 2/ FromType extends/implements FactType; querying for impl type where declared type is its interface.
* 3/ FromType super FactType; querying for interface where declared type is its implementation.
*/
boolean hasMatchingType = problemFactOrEntityClassSet.stream()
.anyMatch(factType -> fromType.isAssignableFrom(factType) || factType.isAssignableFrom(fromType));
if (!hasMatchingType) {
List<String> canonicalClassNameList = problemFactOrEntityClassSet.stream()
.map(Class::getCanonicalName)
.sorted()
.collect(toList());
throw new IllegalArgumentException("Cannot use class (" + fromType.getCanonicalName()
+ ") in a constraint stream as it is neither the same as, nor a superclass or superinterface of "
+ "one of planning entities or problem facts.\n"
+ "Ensure that all from(), join(), ifExists() and ifNotExists() building blocks only reference "
+ "classes assignable from planning entities or problem facts (" + canonicalClassNameList + ") "
+ "annotated on the planning solution (" + solutionDescriptor.getSolutionClass().getCanonicalName()
+ ").");
}
}
public List<Constraint_> buildConstraints(ConstraintProvider constraintProvider) {<FILL_FUNCTION_BODY>}
/**
* @return never null
*/
public abstract SolutionDescriptor<Solution_> getSolutionDescriptor();
}
|
Constraint[] constraints = constraintProvider.defineConstraints(this);
if (constraints == null) {
throw new IllegalStateException("The constraintProvider class (" + constraintProvider.getClass()
+ ")'s defineConstraints() must not return null.\n"
+ "Maybe return an empty array instead if there are no constraints.");
}
if (Arrays.stream(constraints).anyMatch(Objects::isNull)) {
throw new IllegalStateException("The constraintProvider class (" + constraintProvider.getClass()
+ ")'s defineConstraints() must not contain an element that is null.\n"
+ "Maybe don't include any null elements in the " + Constraint.class.getSimpleName() + " array.");
}
// Fail fast on duplicate constraint IDs.
Map<String, List<Constraint>> constraintsPerIdMap =
Arrays.stream(constraints).collect(groupingBy(Constraint::getConstraintId));
constraintsPerIdMap.forEach((constraintId, duplicateConstraintList) -> {
if (duplicateConstraintList.size() > 1) {
throw new IllegalStateException("There are multiple constraints with the same ID (" + constraintId + ").");
}
});
return Arrays.stream(constraints)
.map(c -> (Constraint_) c)
.collect(Collectors.toList());
| 1,314
| 327
| 1,641
|
<no_super_class>
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-common/src/main/java/org/optaplanner/constraint/streams/common/bi/BiConstraintBuilderImpl.java
|
BiConstraintBuilderImpl
|
justifyWith
|
class BiConstraintBuilderImpl<A, B, Score_ extends Score<Score_>>
extends AbstractConstraintBuilder<Score_>
implements BiConstraintBuilder<A, B, Score_> {
private TriFunction<A, B, Score_, ConstraintJustification> justificationMapping;
private BiFunction<A, B, Collection<Object>> indictedObjectsMapping;
public BiConstraintBuilderImpl(BiConstraintConstructor<A, B, Score_> constraintConstructor, ScoreImpactType impactType,
Score_ constraintWeight) {
super(constraintConstructor, impactType, constraintWeight);
}
@Override
protected TriFunction<A, B, Score_, ConstraintJustification> getJustificationMapping() {
return justificationMapping;
}
@Override
public <ConstraintJustification_ extends ConstraintJustification> BiConstraintBuilder<A, B, Score_> justifyWith(
TriFunction<A, B, Score_, ConstraintJustification_> justificationMapping) {<FILL_FUNCTION_BODY>}
@Override
protected BiFunction<A, B, Collection<Object>> getIndictedObjectsMapping() {
return indictedObjectsMapping;
}
@Override
public BiConstraintBuilder<A, B, Score_> indictWith(BiFunction<A, B, Collection<Object>> indictedObjectsMapping) {
if (this.indictedObjectsMapping != null) {
throw new IllegalStateException("Indicted objects' mapping already set (" + indictedObjectsMapping + ").");
}
this.indictedObjectsMapping = Objects.requireNonNull(indictedObjectsMapping);
return this;
}
}
|
if (this.justificationMapping != null) {
throw new IllegalStateException("Justification mapping already set (" + justificationMapping + ").");
}
this.justificationMapping =
(TriFunction<A, B, Score_, ConstraintJustification>) Objects.requireNonNull(justificationMapping);
return this;
| 408
| 85
| 493
|
<methods>public final org.optaplanner.core.api.score.stream.Constraint asConstraint(java.lang.String) ,public final org.optaplanner.core.api.score.stream.Constraint asConstraint(java.lang.String, java.lang.String) <variables>private final non-sealed ConstraintConstructor#RAW constraintConstructor,private final non-sealed Score_ constraintWeight,private final non-sealed org.optaplanner.constraint.streams.common.ScoreImpactType impactType
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-common/src/main/java/org/optaplanner/constraint/streams/common/bi/BiJoinerComber.java
|
BiJoinerComber
|
comb
|
class BiJoinerComber<A, B> {
public static <A, B> BiJoinerComber<A, B> comb(BiJoiner<A, B>[] joiners) {<FILL_FUNCTION_BODY>}
private static <A, B> BiPredicate<A, B> mergeFiltering(List<BiPredicate<A, B>> filteringList) {
if (filteringList.isEmpty()) {
return null;
}
switch (filteringList.size()) {
case 1:
return filteringList.get(0);
case 2:
return filteringList.get(0).and(filteringList.get(1));
default:
// Avoid predicate.and() when more than 2 predicates for debugging and potentially performance
return (A a, B b) -> {
for (BiPredicate<A, B> predicate : filteringList) {
if (!predicate.test(a, b)) {
return false;
}
}
return true;
};
}
}
private DefaultBiJoiner<A, B> mergedJoiner;
private final BiPredicate<A, B> mergedFiltering;
public BiJoinerComber(DefaultBiJoiner<A, B> mergedJoiner, BiPredicate<A, B> mergedFiltering) {
this.mergedJoiner = mergedJoiner;
this.mergedFiltering = mergedFiltering;
}
/**
* @return never null
*/
public DefaultBiJoiner<A, B> getMergedJoiner() {
return mergedJoiner;
}
/**
* @return null if not applicable
*/
public BiPredicate<A, B> getMergedFiltering() {
return mergedFiltering;
}
public void addJoiner(DefaultBiJoiner<A, B> extraJoiner) {
mergedJoiner = mergedJoiner.and(extraJoiner);
}
}
|
List<DefaultBiJoiner<A, B>> defaultJoinerList = new ArrayList<>(joiners.length);
List<BiPredicate<A, B>> filteringList = new ArrayList<>(joiners.length);
int indexOfFirstFilter = -1;
// Make sure all indexing joiners, if any, come before filtering joiners. This is necessary for performance.
for (int i = 0; i < joiners.length; i++) {
BiJoiner<A, B> joiner = joiners[i];
if (joiner instanceof FilteringBiJoiner) {
// From now on, only allow filtering joiners.
indexOfFirstFilter = i;
filteringList.add(((FilteringBiJoiner<A, B>) joiner).getFilter());
} else if (joiner instanceof DefaultBiJoiner) {
if (indexOfFirstFilter >= 0) {
throw new IllegalStateException("Indexing joiner (" + joiner + ") must not follow " +
"a filtering joiner (" + joiners[indexOfFirstFilter] + ").\n" +
"Maybe reorder the joiners such that filtering() joiners are later in the parameter list.");
}
defaultJoinerList.add((DefaultBiJoiner<A, B>) joiner);
} else {
throw new IllegalArgumentException("The joiner class (" + joiner.getClass() + ") is not supported.");
}
}
DefaultBiJoiner<A, B> mergedJoiner = DefaultBiJoiner.merge(defaultJoinerList);
BiPredicate<A, B> mergedFiltering = mergeFiltering(filteringList);
return new BiJoinerComber<>(mergedJoiner, mergedFiltering);
| 497
| 415
| 912
|
<no_super_class>
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-common/src/main/java/org/optaplanner/constraint/streams/common/bi/DefaultBiJoiner.java
|
DefaultBiJoiner
|
matches
|
class DefaultBiJoiner<A, B> extends AbstractJoiner<B> implements BiJoiner<A, B> {
private static final DefaultBiJoiner NONE = new DefaultBiJoiner(new Function[0], new JoinerType[0], new Function[0]);
private final Function<A, ?>[] leftMappings;
public <Property_> DefaultBiJoiner(Function<A, Property_> leftMapping, JoinerType joinerType,
Function<B, Property_> rightMapping) {
super(rightMapping, joinerType);
this.leftMappings = new Function[] { leftMapping };
}
private <Property_> DefaultBiJoiner(Function<A, Property_>[] leftMappings, JoinerType[] joinerTypes,
Function<B, Property_>[] rightMappings) {
super(rightMappings, joinerTypes);
this.leftMappings = leftMappings;
}
public static <A, B> DefaultBiJoiner<A, B> merge(List<DefaultBiJoiner<A, B>> joinerList) {
if (joinerList.size() == 1) {
return joinerList.get(0);
}
return joinerList.stream().reduce(NONE, DefaultBiJoiner::and);
}
@Override
public DefaultBiJoiner<A, B> and(BiJoiner<A, B> otherJoiner) {
DefaultBiJoiner<A, B> castJoiner = (DefaultBiJoiner<A, B>) otherJoiner;
int joinerCount = getJoinerCount();
int castJoinerCount = castJoiner.getJoinerCount();
int newJoinerCount = joinerCount + castJoinerCount;
JoinerType[] newJoinerTypes = Arrays.copyOf(this.joinerTypes, newJoinerCount);
Function[] newLeftMappings = Arrays.copyOf(this.leftMappings, newJoinerCount);
Function[] newRightMappings = Arrays.copyOf(this.rightMappings, newJoinerCount);
for (int i = 0; i < castJoinerCount; i++) {
int newJoinerIndex = i + joinerCount;
newJoinerTypes[newJoinerIndex] = castJoiner.getJoinerType(i);
newLeftMappings[newJoinerIndex] = castJoiner.getLeftMapping(i);
newRightMappings[newJoinerIndex] = castJoiner.getRightMapping(i);
}
return new DefaultBiJoiner<>(newLeftMappings, newJoinerTypes, newRightMappings);
}
public Function<A, Object> getLeftMapping(int index) {
return (Function<A, Object>) leftMappings[index];
}
public boolean matches(A a, B b) {<FILL_FUNCTION_BODY>}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof DefaultBiJoiner)) {
return false;
}
DefaultBiJoiner<?, ?> other = (DefaultBiJoiner<?, ?>) o;
return Arrays.equals(joinerTypes, other.joinerTypes)
&& Arrays.equals(leftMappings, other.leftMappings)
&& Arrays.equals(rightMappings, other.rightMappings);
}
@Override
public int hashCode() {
return Objects.hash(Arrays.hashCode(joinerTypes), Arrays.hashCode(leftMappings), Arrays.hashCode(rightMappings));
}
}
|
int joinerCount = getJoinerCount();
for (int i = 0; i < joinerCount; i++) {
JoinerType joinerType = getJoinerType(i);
Object leftMapping = getLeftMapping(i).apply(a);
Object rightMapping = getRightMapping(i).apply(b);
if (!joinerType.matches(leftMapping, rightMapping)) {
return false;
}
}
return true;
| 895
| 116
| 1,011
|
<methods>public final int getJoinerCount() ,public final org.optaplanner.core.impl.score.stream.JoinerType getJoinerType(int) ,public final Function<B,java.lang.Object> getRightMapping(int) <variables>protected final non-sealed org.optaplanner.core.impl.score.stream.JoinerType[] joinerTypes,protected final non-sealed Function<B,java.lang.Object>[] rightMappings
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-common/src/main/java/org/optaplanner/constraint/streams/common/bi/FilteringBiJoiner.java
|
FilteringBiJoiner
|
equals
|
class FilteringBiJoiner<A, B> implements BiJoiner<A, B> {
private final BiPredicate<A, B> filter;
public FilteringBiJoiner(BiPredicate<A, B> filter) {
this.filter = filter;
}
@Override
public FilteringBiJoiner<A, B> and(BiJoiner<A, B> otherJoiner) {
FilteringBiJoiner<A, B> castJoiner = (FilteringBiJoiner<A, B>) otherJoiner;
return new FilteringBiJoiner<>(filter.and(castJoiner.getFilter()));
}
public BiPredicate<A, B> getFilter() {
return filter;
}
@Override
public boolean equals(Object o) {<FILL_FUNCTION_BODY>}
@Override
public int hashCode() {
return Objects.hash(filter);
}
}
|
if (this == o) {
return true;
}
if (!(o instanceof FilteringBiJoiner)) {
return false;
}
FilteringBiJoiner<?, ?> other = (FilteringBiJoiner<?, ?>) o;
return Objects.equals(filter, other.filter);
| 238
| 82
| 320
|
<no_super_class>
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-common/src/main/java/org/optaplanner/constraint/streams/common/inliner/BendableBigDecimalScoreInliner.java
|
BendableBigDecimalScoreInliner
|
buildWeightedScoreImpacter
|
class BendableBigDecimalScoreInliner extends AbstractScoreInliner<BendableBigDecimalScore> {
private final BigDecimal[] hardScores;
private final BigDecimal[] softScores;
BendableBigDecimalScoreInliner(boolean constraintMatchEnabled, int hardLevelsSize, int softLevelsSize) {
super(constraintMatchEnabled);
hardScores = new BigDecimal[hardLevelsSize];
Arrays.fill(hardScores, BigDecimal.ZERO);
softScores = new BigDecimal[softLevelsSize];
Arrays.fill(softScores, BigDecimal.ZERO);
}
@Override
public WeightedScoreImpacter<BendableBigDecimalScore, BendableBigDecimalScoreContext> buildWeightedScoreImpacter(
Constraint constraint, BendableBigDecimalScore constraintWeight) {<FILL_FUNCTION_BODY>}
@Override
public BendableBigDecimalScore extractScore(int initScore) {
return BendableBigDecimalScore.ofUninitialized(initScore,
Arrays.copyOf(hardScores, hardScores.length),
Arrays.copyOf(softScores, softScores.length));
}
@Override
public String toString() {
return BendableBigDecimalScore.class.getSimpleName() + " inliner";
}
}
|
validateConstraintWeight(constraint, constraintWeight);
Integer singleLevel = null;
for (int i = 0; i < constraintWeight.levelsSize(); i++) {
if (!constraintWeight.hardOrSoftScore(i).equals(BigDecimal.ZERO)) {
if (singleLevel != null) {
singleLevel = null;
break;
}
singleLevel = i;
}
}
IntBigDecimalConsumer hardScoreUpdater =
(scoreLevel, impact) -> this.hardScores[scoreLevel] = this.hardScores[scoreLevel].add(impact);
IntBigDecimalConsumer softScoreUpdater =
(scoreLevel, impact) -> this.softScores[scoreLevel] = this.softScores[scoreLevel].add(impact);
if (singleLevel != null) {
boolean isHardScore = singleLevel < constraintWeight.hardLevelsSize();
int level = isHardScore ? singleLevel : singleLevel - constraintWeight.hardLevelsSize();
BendableBigDecimalScoreContext context = new BendableBigDecimalScoreContext(this, constraint, constraintWeight,
hardScores.length, softScores.length, level, constraintWeight.hardOrSoftScore(singleLevel),
hardScoreUpdater, softScoreUpdater);
if (isHardScore) {
return WeightedScoreImpacter.of(context, BendableBigDecimalScoreContext::changeHardScoreBy);
} else {
return WeightedScoreImpacter.of(context, BendableBigDecimalScoreContext::changeSoftScoreBy);
}
} else {
BendableBigDecimalScoreContext context = new BendableBigDecimalScoreContext(this, constraint, constraintWeight,
hardScores.length, softScores.length, hardScoreUpdater, softScoreUpdater);
return WeightedScoreImpacter.of(context, BendableBigDecimalScoreContext::changeScoreBy);
}
| 368
| 494
| 862
|
<methods>public static ScoreInliner_ buildScoreInliner(ScoreDefinition<Score_>, boolean) ,public abstract WeightedScoreImpacter<org.optaplanner.core.api.score.buildin.bendablebigdecimal.BendableBigDecimalScore,?> buildWeightedScoreImpacter(org.optaplanner.core.api.score.stream.Constraint, org.optaplanner.core.api.score.buildin.bendablebigdecimal.BendableBigDecimalScore) ,public abstract org.optaplanner.core.api.score.buildin.bendablebigdecimal.BendableBigDecimalScore extractScore(int) ,public final Map<java.lang.String,ConstraintMatchTotal<org.optaplanner.core.api.score.buildin.bendablebigdecimal.BendableBigDecimalScore>> getConstraintMatchTotalMap() ,public final Map<java.lang.Object,Indictment<org.optaplanner.core.api.score.buildin.bendablebigdecimal.BendableBigDecimalScore>> getIndictmentMap() ,public boolean isConstraintMatchEnabled() <variables>private static final java.lang.String CUSTOM_SCORE_INLINER_CLASS_PROPERTY_NAME,protected final non-sealed boolean constraintMatchEnabled,private final non-sealed Map<java.lang.String,DefaultConstraintMatchTotal<org.optaplanner.core.api.score.buildin.bendablebigdecimal.BendableBigDecimalScore>> constraintMatchTotalMap,private final non-sealed Map<java.lang.Object,DefaultIndictment<org.optaplanner.core.api.score.buildin.bendablebigdecimal.BendableBigDecimalScore>> indictmentMap
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-common/src/main/java/org/optaplanner/constraint/streams/common/inliner/BendableLongScoreInliner.java
|
BendableLongScoreInliner
|
buildWeightedScoreImpacter
|
class BendableLongScoreInliner extends AbstractScoreInliner<BendableLongScore> {
private final long[] hardScores;
private final long[] softScores;
BendableLongScoreInliner(boolean constraintMatchEnabled, int hardLevelsSize, int softLevelsSize) {
super(constraintMatchEnabled);
hardScores = new long[hardLevelsSize];
softScores = new long[softLevelsSize];
}
@Override
public WeightedScoreImpacter<BendableLongScore, BendableLongScoreContext> buildWeightedScoreImpacter(Constraint constraint,
BendableLongScore constraintWeight) {<FILL_FUNCTION_BODY>}
@Override
public BendableLongScore extractScore(int initScore) {
return BendableLongScore.ofUninitialized(initScore,
Arrays.copyOf(hardScores, hardScores.length),
Arrays.copyOf(softScores, softScores.length));
}
@Override
public String toString() {
return BendableLongScore.class.getSimpleName() + " inliner";
}
}
|
validateConstraintWeight(constraint, constraintWeight);
Integer singleLevel = null;
for (int i = 0; i < constraintWeight.levelsSize(); i++) {
if (constraintWeight.hardOrSoftScore(i) != 0L) {
if (singleLevel != null) {
singleLevel = null;
break;
}
singleLevel = i;
}
}
IntLongConsumer hardScoreUpdater = (scoreLevel, impact) -> this.hardScores[scoreLevel] += impact;
IntLongConsumer softScoreUpdater = (scoreLevel, impact) -> this.softScores[scoreLevel] += impact;
if (singleLevel != null) {
boolean isHardScore = singleLevel < constraintWeight.hardLevelsSize();
int level = isHardScore ? singleLevel : singleLevel - constraintWeight.hardLevelsSize();
BendableLongScoreContext context = new BendableLongScoreContext(this, constraint, constraintWeight,
hardScores.length, softScores.length, level, constraintWeight.hardOrSoftScore(singleLevel),
hardScoreUpdater, softScoreUpdater);
if (isHardScore) {
return WeightedScoreImpacter.of(context, (BendableLongScoreContext ctx, long impact,
JustificationsSupplier justificationSupplier) -> ctx.changeHardScoreBy(impact, justificationSupplier));
} else {
return WeightedScoreImpacter.of(context, (BendableLongScoreContext ctx, long impact,
JustificationsSupplier justificationSupplier) -> ctx.changeSoftScoreBy(impact, justificationSupplier));
}
} else {
BendableLongScoreContext context = new BendableLongScoreContext(this, constraint, constraintWeight,
hardScores.length, softScores.length, hardScoreUpdater, softScoreUpdater);
return WeightedScoreImpacter.of(context, (BendableLongScoreContext ctx, long impact,
JustificationsSupplier justificationSupplier) -> ctx.changeScoreBy(impact, justificationSupplier));
}
| 301
| 525
| 826
|
<methods>public static ScoreInliner_ buildScoreInliner(ScoreDefinition<Score_>, boolean) ,public abstract WeightedScoreImpacter<org.optaplanner.core.api.score.buildin.bendablelong.BendableLongScore,?> buildWeightedScoreImpacter(org.optaplanner.core.api.score.stream.Constraint, org.optaplanner.core.api.score.buildin.bendablelong.BendableLongScore) ,public abstract org.optaplanner.core.api.score.buildin.bendablelong.BendableLongScore extractScore(int) ,public final Map<java.lang.String,ConstraintMatchTotal<org.optaplanner.core.api.score.buildin.bendablelong.BendableLongScore>> getConstraintMatchTotalMap() ,public final Map<java.lang.Object,Indictment<org.optaplanner.core.api.score.buildin.bendablelong.BendableLongScore>> getIndictmentMap() ,public boolean isConstraintMatchEnabled() <variables>private static final java.lang.String CUSTOM_SCORE_INLINER_CLASS_PROPERTY_NAME,protected final non-sealed boolean constraintMatchEnabled,private final non-sealed Map<java.lang.String,DefaultConstraintMatchTotal<org.optaplanner.core.api.score.buildin.bendablelong.BendableLongScore>> constraintMatchTotalMap,private final non-sealed Map<java.lang.Object,DefaultIndictment<org.optaplanner.core.api.score.buildin.bendablelong.BendableLongScore>> indictmentMap
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-common/src/main/java/org/optaplanner/constraint/streams/common/inliner/BendableScoreContext.java
|
BendableScoreContext
|
changeHardScoreBy
|
class BendableScoreContext extends ScoreContext<BendableScore> {
private final int hardScoreLevelCount;
private final int softScoreLevelCount;
private final int scoreLevel;
private final int scoreLevelWeight;
private final IntBiConsumer softScoreLevelUpdater;
private final IntBiConsumer hardScoreLevelUpdater;
public BendableScoreContext(AbstractScoreInliner<BendableScore> parent, Constraint constraint,
BendableScore constraintWeight, int hardScoreLevelCount, int softScoreLevelCount, int scoreLevel,
int scoreLevelWeight, IntBiConsumer hardScoreLevelUpdater, IntBiConsumer softScoreLevelUpdater) {
super(parent, constraint, constraintWeight);
this.hardScoreLevelCount = hardScoreLevelCount;
this.softScoreLevelCount = softScoreLevelCount;
this.scoreLevel = scoreLevel;
this.scoreLevelWeight = scoreLevelWeight;
this.softScoreLevelUpdater = softScoreLevelUpdater;
this.hardScoreLevelUpdater = hardScoreLevelUpdater;
}
public BendableScoreContext(AbstractScoreInliner<BendableScore> parent, Constraint constraint,
BendableScore constraintWeight, int hardScoreLevelCount, int softScoreLevelCount,
IntBiConsumer hardScoreLevelUpdater, IntBiConsumer softScoreLevelUpdater) {
this(parent, constraint, constraintWeight, hardScoreLevelCount, softScoreLevelCount, -1, -1, hardScoreLevelUpdater,
softScoreLevelUpdater);
}
public UndoScoreImpacter changeSoftScoreBy(int matchWeight, JustificationsSupplier justificationsSupplier) {
int softImpact = scoreLevelWeight * matchWeight;
softScoreLevelUpdater.accept(scoreLevel, softImpact);
UndoScoreImpacter undoScoreImpact = () -> softScoreLevelUpdater.accept(scoreLevel, -softImpact);
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact,
BendableScore.ofSoft(hardScoreLevelCount, softScoreLevelCount, scoreLevel, softImpact), justificationsSupplier);
}
public UndoScoreImpacter changeHardScoreBy(int matchWeight, JustificationsSupplier justificationsSupplier) {<FILL_FUNCTION_BODY>}
public UndoScoreImpacter changeScoreBy(int matchWeight, JustificationsSupplier justificationsSupplier) {
int[] hardImpacts = new int[hardScoreLevelCount];
int[] softImpacts = new int[softScoreLevelCount];
for (int hardScoreLevel = 0; hardScoreLevel < hardScoreLevelCount; hardScoreLevel++) {
int hardImpact = constraintWeight.hardScore(hardScoreLevel) * matchWeight;
hardImpacts[hardScoreLevel] = hardImpact;
hardScoreLevelUpdater.accept(hardScoreLevel, hardImpact);
}
for (int softScoreLevel = 0; softScoreLevel < softScoreLevelCount; softScoreLevel++) {
int softImpact = constraintWeight.softScore(softScoreLevel) * matchWeight;
softImpacts[softScoreLevel] = softImpact;
softScoreLevelUpdater.accept(softScoreLevel, softImpact);
}
UndoScoreImpacter undoScoreImpact = () -> {
for (int hardScoreLevel = 0; hardScoreLevel < hardScoreLevelCount; hardScoreLevel++) {
hardScoreLevelUpdater.accept(hardScoreLevel, -hardImpacts[hardScoreLevel]);
}
for (int softScoreLevel = 0; softScoreLevel < softScoreLevelCount; softScoreLevel++) {
softScoreLevelUpdater.accept(softScoreLevel, -softImpacts[softScoreLevel]);
}
};
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, BendableScore.of(hardImpacts, softImpacts), justificationsSupplier);
}
public interface IntBiConsumer {
void accept(int value1, int value2);
}
}
|
int hardImpact = scoreLevelWeight * matchWeight;
hardScoreLevelUpdater.accept(scoreLevel, hardImpact);
UndoScoreImpacter undoScoreImpact = () -> hardScoreLevelUpdater.accept(scoreLevel, -hardImpact);
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact,
BendableScore.ofHard(hardScoreLevelCount, softScoreLevelCount, scoreLevel, hardImpact), justificationsSupplier);
| 1,060
| 142
| 1,202
|
<methods>public org.optaplanner.core.api.score.stream.Constraint getConstraint() ,public org.optaplanner.core.api.score.buildin.bendable.BendableScore getConstraintWeight() ,public boolean isConstraintMatchEnabled() <variables>protected final non-sealed org.optaplanner.core.api.score.stream.Constraint constraint,protected final non-sealed boolean constraintMatchEnabled,protected final non-sealed org.optaplanner.core.api.score.buildin.bendable.BendableScore constraintWeight,private final non-sealed AbstractScoreInliner<org.optaplanner.core.api.score.buildin.bendable.BendableScore> parent
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-common/src/main/java/org/optaplanner/constraint/streams/common/inliner/BendableScoreInliner.java
|
BendableScoreInliner
|
buildWeightedScoreImpacter
|
class BendableScoreInliner extends AbstractScoreInliner<BendableScore> {
private final int[] hardScores;
private final int[] softScores;
BendableScoreInliner(boolean constraintMatchEnabled, int hardLevelsSize, int softLevelsSize) {
super(constraintMatchEnabled);
hardScores = new int[hardLevelsSize];
softScores = new int[softLevelsSize];
}
@Override
public WeightedScoreImpacter<BendableScore, BendableScoreContext> buildWeightedScoreImpacter(Constraint constraint,
BendableScore constraintWeight) {<FILL_FUNCTION_BODY>}
@Override
public BendableScore extractScore(int initScore) {
return BendableScore.ofUninitialized(initScore,
Arrays.copyOf(hardScores, hardScores.length),
Arrays.copyOf(softScores, softScores.length));
}
@Override
public String toString() {
return BendableScore.class.getSimpleName() + " inliner";
}
}
|
validateConstraintWeight(constraint, constraintWeight);
Integer singleLevel = null;
for (int i = 0; i < constraintWeight.levelsSize(); i++) {
if (constraintWeight.hardOrSoftScore(i) != 0L) {
if (singleLevel != null) {
singleLevel = null;
break;
}
singleLevel = i;
}
}
IntBiConsumer hardScoreUpdater = (scoreLevel, impact) -> this.hardScores[scoreLevel] += impact;
IntBiConsumer softScoreUpdater = (scoreLevel, impact) -> this.softScores[scoreLevel] += impact;
if (singleLevel != null) {
boolean isHardScore = singleLevel < constraintWeight.hardLevelsSize();
int level = isHardScore ? singleLevel : singleLevel - constraintWeight.hardLevelsSize();
BendableScoreContext context = new BendableScoreContext(this, constraint, constraintWeight,
hardScores.length, softScores.length, level, constraintWeight.hardOrSoftScore(singleLevel),
hardScoreUpdater, softScoreUpdater);
if (isHardScore) {
return WeightedScoreImpacter.of(context, BendableScoreContext::changeHardScoreBy);
} else {
return WeightedScoreImpacter.of(context, BendableScoreContext::changeSoftScoreBy);
}
} else {
BendableScoreContext context = new BendableScoreContext(this, constraint, constraintWeight,
hardScores.length, softScores.length, hardScoreUpdater, softScoreUpdater);
return WeightedScoreImpacter.of(context, BendableScoreContext::changeScoreBy);
}
| 292
| 434
| 726
|
<methods>public static ScoreInliner_ buildScoreInliner(ScoreDefinition<Score_>, boolean) ,public abstract WeightedScoreImpacter<org.optaplanner.core.api.score.buildin.bendable.BendableScore,?> buildWeightedScoreImpacter(org.optaplanner.core.api.score.stream.Constraint, org.optaplanner.core.api.score.buildin.bendable.BendableScore) ,public abstract org.optaplanner.core.api.score.buildin.bendable.BendableScore extractScore(int) ,public final Map<java.lang.String,ConstraintMatchTotal<org.optaplanner.core.api.score.buildin.bendable.BendableScore>> getConstraintMatchTotalMap() ,public final Map<java.lang.Object,Indictment<org.optaplanner.core.api.score.buildin.bendable.BendableScore>> getIndictmentMap() ,public boolean isConstraintMatchEnabled() <variables>private static final java.lang.String CUSTOM_SCORE_INLINER_CLASS_PROPERTY_NAME,protected final non-sealed boolean constraintMatchEnabled,private final non-sealed Map<java.lang.String,DefaultConstraintMatchTotal<org.optaplanner.core.api.score.buildin.bendable.BendableScore>> constraintMatchTotalMap,private final non-sealed Map<java.lang.Object,DefaultIndictment<org.optaplanner.core.api.score.buildin.bendable.BendableScore>> indictmentMap
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-common/src/main/java/org/optaplanner/constraint/streams/common/inliner/HardMediumSoftBigDecimalScoreContext.java
|
HardMediumSoftBigDecimalScoreContext
|
changeHardScoreBy
|
class HardMediumSoftBigDecimalScoreContext extends ScoreContext<HardMediumSoftBigDecimalScore> {
private final Consumer<BigDecimal> softScoreUpdater;
private final Consumer<BigDecimal> mediumScoreUpdater;
private final Consumer<BigDecimal> hardScoreUpdater;
public HardMediumSoftBigDecimalScoreContext(AbstractScoreInliner<HardMediumSoftBigDecimalScore> parent,
Constraint constraint, HardMediumSoftBigDecimalScore constraintWeight, Consumer<BigDecimal> hardScoreUpdater,
Consumer<BigDecimal> mediumScoreUpdater, Consumer<BigDecimal> softScoreUpdater) {
super(parent, constraint, constraintWeight);
this.softScoreUpdater = softScoreUpdater;
this.mediumScoreUpdater = mediumScoreUpdater;
this.hardScoreUpdater = hardScoreUpdater;
}
public UndoScoreImpacter changeSoftScoreBy(BigDecimal matchWeight, JustificationsSupplier justificationsSupplier) {
BigDecimal softImpact = constraintWeight.softScore().multiply(matchWeight);
softScoreUpdater.accept(softImpact);
UndoScoreImpacter undoScoreImpact = () -> softScoreUpdater.accept(softImpact.negate());
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftBigDecimalScore.ofSoft(softImpact),
justificationsSupplier);
}
public UndoScoreImpacter changeMediumScoreBy(BigDecimal matchWeight, JustificationsSupplier justificationsSupplier) {
BigDecimal mediumImpact = constraintWeight.mediumScore().multiply(matchWeight);
mediumScoreUpdater.accept(mediumImpact);
UndoScoreImpacter undoScoreImpact = () -> mediumScoreUpdater.accept(mediumImpact.negate());
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftBigDecimalScore.ofMedium(mediumImpact),
justificationsSupplier);
}
public UndoScoreImpacter changeHardScoreBy(BigDecimal matchWeight, JustificationsSupplier justificationsSupplier) {<FILL_FUNCTION_BODY>}
public UndoScoreImpacter changeScoreBy(BigDecimal matchWeight, JustificationsSupplier justificationsSupplier) {
BigDecimal hardImpact = constraintWeight.hardScore().multiply(matchWeight);
BigDecimal mediumImpact = constraintWeight.mediumScore().multiply(matchWeight);
BigDecimal softImpact = constraintWeight.softScore().multiply(matchWeight);
hardScoreUpdater.accept(hardImpact);
mediumScoreUpdater.accept(mediumImpact);
softScoreUpdater.accept(softImpact);
UndoScoreImpacter undoScoreImpact = () -> {
hardScoreUpdater.accept(hardImpact.negate());
mediumScoreUpdater.accept(mediumImpact.negate());
softScoreUpdater.accept(softImpact.negate());
};
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact,
HardMediumSoftBigDecimalScore.of(hardImpact, mediumImpact, softImpact), justificationsSupplier);
}
}
|
BigDecimal hardImpact = constraintWeight.hardScore().multiply(matchWeight);
hardScoreUpdater.accept(hardImpact);
UndoScoreImpacter undoScoreImpact = () -> hardScoreUpdater.accept(hardImpact.negate());
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftBigDecimalScore.ofHard(hardImpact),
justificationsSupplier);
| 902
| 135
| 1,037
|
<methods>public org.optaplanner.core.api.score.stream.Constraint getConstraint() ,public org.optaplanner.core.api.score.buildin.hardmediumsoftbigdecimal.HardMediumSoftBigDecimalScore getConstraintWeight() ,public boolean isConstraintMatchEnabled() <variables>protected final non-sealed org.optaplanner.core.api.score.stream.Constraint constraint,protected final non-sealed boolean constraintMatchEnabled,protected final non-sealed org.optaplanner.core.api.score.buildin.hardmediumsoftbigdecimal.HardMediumSoftBigDecimalScore constraintWeight,private final non-sealed AbstractScoreInliner<org.optaplanner.core.api.score.buildin.hardmediumsoftbigdecimal.HardMediumSoftBigDecimalScore> parent
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-common/src/main/java/org/optaplanner/constraint/streams/common/inliner/HardMediumSoftBigDecimalScoreInliner.java
|
HardMediumSoftBigDecimalScoreInliner
|
buildWeightedScoreImpacter
|
class HardMediumSoftBigDecimalScoreInliner extends AbstractScoreInliner<HardMediumSoftBigDecimalScore> {
private BigDecimal hardScore = BigDecimal.ZERO;
private BigDecimal mediumScore = BigDecimal.ZERO;
private BigDecimal softScore = BigDecimal.ZERO;
HardMediumSoftBigDecimalScoreInliner(boolean constraintMatchEnabled) {
super(constraintMatchEnabled);
}
@Override
public WeightedScoreImpacter<HardMediumSoftBigDecimalScore, HardMediumSoftBigDecimalScoreContext>
buildWeightedScoreImpacter(Constraint constraint,
HardMediumSoftBigDecimalScore constraintWeight) {<FILL_FUNCTION_BODY>}
@Override
public HardMediumSoftBigDecimalScore extractScore(int initScore) {
return HardMediumSoftBigDecimalScore.ofUninitialized(initScore, hardScore, mediumScore, softScore);
}
@Override
public String toString() {
return HardMediumSoftBigDecimalScore.class.getSimpleName() + " inliner";
}
}
|
validateConstraintWeight(constraint, constraintWeight);
BigDecimal hardConstraintWeight = constraintWeight.hardScore();
BigDecimal mediumConstraintWeight = constraintWeight.mediumScore();
BigDecimal softConstraintWeight = constraintWeight.softScore();
HardMediumSoftBigDecimalScoreContext context =
new HardMediumSoftBigDecimalScoreContext(this, constraint, constraintWeight,
impact -> this.hardScore = this.hardScore.add(impact),
impact -> this.mediumScore = this.mediumScore.add(impact),
impact -> this.softScore = this.softScore.add(impact));
if (mediumConstraintWeight.equals(BigDecimal.ZERO) && softConstraintWeight.equals(BigDecimal.ZERO)) {
return WeightedScoreImpacter.of(context, HardMediumSoftBigDecimalScoreContext::changeHardScoreBy);
} else if (hardConstraintWeight.equals(BigDecimal.ZERO) && softConstraintWeight.equals(BigDecimal.ZERO)) {
return WeightedScoreImpacter.of(context, HardMediumSoftBigDecimalScoreContext::changeMediumScoreBy);
} else if (hardConstraintWeight.equals(BigDecimal.ZERO) && mediumConstraintWeight.equals(BigDecimal.ZERO)) {
return WeightedScoreImpacter.of(context, HardMediumSoftBigDecimalScoreContext::changeSoftScoreBy);
} else {
return WeightedScoreImpacter.of(context, HardMediumSoftBigDecimalScoreContext::changeScoreBy);
}
| 286
| 382
| 668
|
<methods>public static ScoreInliner_ buildScoreInliner(ScoreDefinition<Score_>, boolean) ,public abstract WeightedScoreImpacter<org.optaplanner.core.api.score.buildin.hardmediumsoftbigdecimal.HardMediumSoftBigDecimalScore,?> buildWeightedScoreImpacter(org.optaplanner.core.api.score.stream.Constraint, org.optaplanner.core.api.score.buildin.hardmediumsoftbigdecimal.HardMediumSoftBigDecimalScore) ,public abstract org.optaplanner.core.api.score.buildin.hardmediumsoftbigdecimal.HardMediumSoftBigDecimalScore extractScore(int) ,public final Map<java.lang.String,ConstraintMatchTotal<org.optaplanner.core.api.score.buildin.hardmediumsoftbigdecimal.HardMediumSoftBigDecimalScore>> getConstraintMatchTotalMap() ,public final Map<java.lang.Object,Indictment<org.optaplanner.core.api.score.buildin.hardmediumsoftbigdecimal.HardMediumSoftBigDecimalScore>> getIndictmentMap() ,public boolean isConstraintMatchEnabled() <variables>private static final java.lang.String CUSTOM_SCORE_INLINER_CLASS_PROPERTY_NAME,protected final non-sealed boolean constraintMatchEnabled,private final non-sealed Map<java.lang.String,DefaultConstraintMatchTotal<org.optaplanner.core.api.score.buildin.hardmediumsoftbigdecimal.HardMediumSoftBigDecimalScore>> constraintMatchTotalMap,private final non-sealed Map<java.lang.Object,DefaultIndictment<org.optaplanner.core.api.score.buildin.hardmediumsoftbigdecimal.HardMediumSoftBigDecimalScore>> indictmentMap
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-common/src/main/java/org/optaplanner/constraint/streams/common/inliner/HardMediumSoftLongScoreContext.java
|
HardMediumSoftLongScoreContext
|
changeScoreBy
|
class HardMediumSoftLongScoreContext extends ScoreContext<HardMediumSoftLongScore> {
private final LongConsumer softScoreUpdater;
private final LongConsumer mediumScoreUpdater;
private final LongConsumer hardScoreUpdater;
public HardMediumSoftLongScoreContext(AbstractScoreInliner<HardMediumSoftLongScore> parent, Constraint constraint,
HardMediumSoftLongScore constraintWeight, LongConsumer hardScoreUpdater, LongConsumer mediumScoreUpdater,
LongConsumer softScoreUpdater) {
super(parent, constraint, constraintWeight);
this.softScoreUpdater = softScoreUpdater;
this.mediumScoreUpdater = mediumScoreUpdater;
this.hardScoreUpdater = hardScoreUpdater;
}
public UndoScoreImpacter changeSoftScoreBy(long matchWeight, JustificationsSupplier justificationsSupplier) {
long softImpact = constraintWeight.softScore() * matchWeight;
softScoreUpdater.accept(softImpact);
UndoScoreImpacter undoScoreImpact = () -> softScoreUpdater.accept(-softImpact);
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftLongScore.ofSoft(softImpact), justificationsSupplier);
}
public UndoScoreImpacter changeMediumScoreBy(long matchWeight, JustificationsSupplier justificationsSupplier) {
long mediumImpact = constraintWeight.mediumScore() * matchWeight;
mediumScoreUpdater.accept(mediumImpact);
UndoScoreImpacter undoScoreImpact = () -> mediumScoreUpdater.accept(-mediumImpact);
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftLongScore.ofMedium(mediumImpact),
justificationsSupplier);
}
public UndoScoreImpacter changeHardScoreBy(long matchWeight, JustificationsSupplier justificationsSupplier) {
long hardImpact = constraintWeight.hardScore() * matchWeight;
hardScoreUpdater.accept(hardImpact);
UndoScoreImpacter undoScoreImpact = () -> hardScoreUpdater.accept(-hardImpact);
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftLongScore.ofHard(hardImpact), justificationsSupplier);
}
public UndoScoreImpacter changeScoreBy(long matchWeight, JustificationsSupplier justificationsSupplier) {<FILL_FUNCTION_BODY>}
}
|
long hardImpact = constraintWeight.hardScore() * matchWeight;
long mediumImpact = constraintWeight.mediumScore() * matchWeight;
long softImpact = constraintWeight.softScore() * matchWeight;
hardScoreUpdater.accept(hardImpact);
mediumScoreUpdater.accept(mediumImpact);
softScoreUpdater.accept(softImpact);
UndoScoreImpacter undoScoreImpact = () -> {
hardScoreUpdater.accept(-hardImpact);
mediumScoreUpdater.accept(-mediumImpact);
softScoreUpdater.accept(-softImpact);
};
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftLongScore.of(hardImpact, mediumImpact, softImpact),
justificationsSupplier);
| 693
| 236
| 929
|
<methods>public org.optaplanner.core.api.score.stream.Constraint getConstraint() ,public org.optaplanner.core.api.score.buildin.hardmediumsoftlong.HardMediumSoftLongScore getConstraintWeight() ,public boolean isConstraintMatchEnabled() <variables>protected final non-sealed org.optaplanner.core.api.score.stream.Constraint constraint,protected final non-sealed boolean constraintMatchEnabled,protected final non-sealed org.optaplanner.core.api.score.buildin.hardmediumsoftlong.HardMediumSoftLongScore constraintWeight,private final non-sealed AbstractScoreInliner<org.optaplanner.core.api.score.buildin.hardmediumsoftlong.HardMediumSoftLongScore> parent
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-common/src/main/java/org/optaplanner/constraint/streams/common/inliner/HardMediumSoftScoreInliner.java
|
HardMediumSoftScoreInliner
|
buildWeightedScoreImpacter
|
class HardMediumSoftScoreInliner extends AbstractScoreInliner<HardMediumSoftScore> {
private int hardScore;
private int mediumScore;
private int softScore;
HardMediumSoftScoreInliner(boolean constraintMatchEnabled) {
super(constraintMatchEnabled);
}
@Override
public WeightedScoreImpacter<HardMediumSoftScore, HardMediumSoftScoreContext> buildWeightedScoreImpacter(
Constraint constraint, HardMediumSoftScore constraintWeight) {<FILL_FUNCTION_BODY>}
@Override
public HardMediumSoftScore extractScore(int initScore) {
return HardMediumSoftScore.ofUninitialized(initScore, hardScore, mediumScore, softScore);
}
@Override
public String toString() {
return HardMediumSoftScore.class.getSimpleName() + " inliner";
}
}
|
validateConstraintWeight(constraint, constraintWeight);
int hardConstraintWeight = constraintWeight.hardScore();
int mediumConstraintWeight = constraintWeight.mediumScore();
int softConstraintWeight = constraintWeight.softScore();
HardMediumSoftScoreContext context =
new HardMediumSoftScoreContext(this, constraint, constraintWeight,
impact -> this.hardScore += impact, impact -> this.mediumScore += impact,
impact -> this.softScore += impact);
if (mediumConstraintWeight == 0 && softConstraintWeight == 0) {
return WeightedScoreImpacter.of(context, HardMediumSoftScoreContext::changeHardScoreBy);
} else if (hardConstraintWeight == 0 && softConstraintWeight == 0) {
return WeightedScoreImpacter.of(context, HardMediumSoftScoreContext::changeMediumScoreBy);
} else if (hardConstraintWeight == 0 && mediumConstraintWeight == 0) {
return WeightedScoreImpacter.of(context, HardMediumSoftScoreContext::changeSoftScoreBy);
} else {
return WeightedScoreImpacter.of(context, HardMediumSoftScoreContext::changeScoreBy);
}
| 228
| 281
| 509
|
<methods>public static ScoreInliner_ buildScoreInliner(ScoreDefinition<Score_>, boolean) ,public abstract WeightedScoreImpacter<org.optaplanner.core.api.score.buildin.hardmediumsoft.HardMediumSoftScore,?> buildWeightedScoreImpacter(org.optaplanner.core.api.score.stream.Constraint, org.optaplanner.core.api.score.buildin.hardmediumsoft.HardMediumSoftScore) ,public abstract org.optaplanner.core.api.score.buildin.hardmediumsoft.HardMediumSoftScore extractScore(int) ,public final Map<java.lang.String,ConstraintMatchTotal<org.optaplanner.core.api.score.buildin.hardmediumsoft.HardMediumSoftScore>> getConstraintMatchTotalMap() ,public final Map<java.lang.Object,Indictment<org.optaplanner.core.api.score.buildin.hardmediumsoft.HardMediumSoftScore>> getIndictmentMap() ,public boolean isConstraintMatchEnabled() <variables>private static final java.lang.String CUSTOM_SCORE_INLINER_CLASS_PROPERTY_NAME,protected final non-sealed boolean constraintMatchEnabled,private final non-sealed Map<java.lang.String,DefaultConstraintMatchTotal<org.optaplanner.core.api.score.buildin.hardmediumsoft.HardMediumSoftScore>> constraintMatchTotalMap,private final non-sealed Map<java.lang.Object,DefaultIndictment<org.optaplanner.core.api.score.buildin.hardmediumsoft.HardMediumSoftScore>> indictmentMap
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-common/src/main/java/org/optaplanner/constraint/streams/common/inliner/HardSoftBigDecimalScoreContext.java
|
HardSoftBigDecimalScoreContext
|
changeScoreBy
|
class HardSoftBigDecimalScoreContext extends ScoreContext<HardSoftBigDecimalScore> {
private final Consumer<BigDecimal> softScoreUpdater;
private final Consumer<BigDecimal> hardScoreUpdater;
public HardSoftBigDecimalScoreContext(AbstractScoreInliner<HardSoftBigDecimalScore> parent, Constraint constraint,
HardSoftBigDecimalScore constraintWeight, Consumer<BigDecimal> hardScoreUpdater,
Consumer<BigDecimal> softScoreUpdater) {
super(parent, constraint, constraintWeight);
this.softScoreUpdater = softScoreUpdater;
this.hardScoreUpdater = hardScoreUpdater;
}
public UndoScoreImpacter changeSoftScoreBy(BigDecimal matchWeight, JustificationsSupplier justificationsSupplier) {
BigDecimal softImpact = constraintWeight.softScore().multiply(matchWeight);
softScoreUpdater.accept(softImpact);
UndoScoreImpacter undoScoreImpact = () -> softScoreUpdater.accept(softImpact.negate());
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardSoftBigDecimalScore.ofSoft(softImpact), justificationsSupplier);
}
public UndoScoreImpacter changeHardScoreBy(BigDecimal matchWeight, JustificationsSupplier justificationsSupplier) {
BigDecimal hardImpact = constraintWeight.hardScore().multiply(matchWeight);
hardScoreUpdater.accept(hardImpact);
UndoScoreImpacter undoScoreImpact = () -> hardScoreUpdater.accept(hardImpact.negate());
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardSoftBigDecimalScore.ofHard(hardImpact), justificationsSupplier);
}
public UndoScoreImpacter changeScoreBy(BigDecimal matchWeight, JustificationsSupplier justificationsSupplier) {<FILL_FUNCTION_BODY>}
}
|
BigDecimal hardImpact = constraintWeight.hardScore().multiply(matchWeight);
BigDecimal softImpact = constraintWeight.softScore().multiply(matchWeight);
hardScoreUpdater.accept(hardImpact);
softScoreUpdater.accept(softImpact);
UndoScoreImpacter undoScoreImpact = () -> {
hardScoreUpdater.accept(hardImpact.negate());
softScoreUpdater.accept(softImpact.negate());
};
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardSoftBigDecimalScore.of(hardImpact, softImpact),
justificationsSupplier);
| 543
| 199
| 742
|
<methods>public org.optaplanner.core.api.score.stream.Constraint getConstraint() ,public org.optaplanner.core.api.score.buildin.hardsoftbigdecimal.HardSoftBigDecimalScore getConstraintWeight() ,public boolean isConstraintMatchEnabled() <variables>protected final non-sealed org.optaplanner.core.api.score.stream.Constraint constraint,protected final non-sealed boolean constraintMatchEnabled,protected final non-sealed org.optaplanner.core.api.score.buildin.hardsoftbigdecimal.HardSoftBigDecimalScore constraintWeight,private final non-sealed AbstractScoreInliner<org.optaplanner.core.api.score.buildin.hardsoftbigdecimal.HardSoftBigDecimalScore> parent
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-common/src/main/java/org/optaplanner/constraint/streams/common/inliner/HardSoftBigDecimalScoreInliner.java
|
HardSoftBigDecimalScoreInliner
|
buildWeightedScoreImpacter
|
class HardSoftBigDecimalScoreInliner extends AbstractScoreInliner<HardSoftBigDecimalScore> {
private BigDecimal hardScore = BigDecimal.ZERO;
private BigDecimal softScore = BigDecimal.ZERO;
HardSoftBigDecimalScoreInliner(boolean constraintMatchEnabled) {
super(constraintMatchEnabled);
}
@Override
public WeightedScoreImpacter<HardSoftBigDecimalScore, HardSoftBigDecimalScoreContext> buildWeightedScoreImpacter(
Constraint constraint, HardSoftBigDecimalScore constraintWeight) {<FILL_FUNCTION_BODY>}
@Override
public HardSoftBigDecimalScore extractScore(int initScore) {
return HardSoftBigDecimalScore.ofUninitialized(initScore, hardScore, softScore);
}
@Override
public String toString() {
return HardSoftBigDecimalScore.class.getSimpleName() + " inliner";
}
}
|
validateConstraintWeight(constraint, constraintWeight);
HardSoftBigDecimalScoreContext context =
new HardSoftBigDecimalScoreContext(this, constraint, constraintWeight,
impact -> this.hardScore = this.hardScore.add(impact),
impact -> this.softScore = this.softScore.add(impact));
if (constraintWeight.softScore().equals(BigDecimal.ZERO)) {
return WeightedScoreImpacter.of(context, HardSoftBigDecimalScoreContext::changeHardScoreBy);
} else if (constraintWeight.hardScore().equals(BigDecimal.ZERO)) {
return WeightedScoreImpacter.of(context, HardSoftBigDecimalScoreContext::changeSoftScoreBy);
} else {
return WeightedScoreImpacter.of(context, HardSoftBigDecimalScoreContext::changeScoreBy);
}
| 247
| 215
| 462
|
<methods>public static ScoreInliner_ buildScoreInliner(ScoreDefinition<Score_>, boolean) ,public abstract WeightedScoreImpacter<org.optaplanner.core.api.score.buildin.hardsoftbigdecimal.HardSoftBigDecimalScore,?> buildWeightedScoreImpacter(org.optaplanner.core.api.score.stream.Constraint, org.optaplanner.core.api.score.buildin.hardsoftbigdecimal.HardSoftBigDecimalScore) ,public abstract org.optaplanner.core.api.score.buildin.hardsoftbigdecimal.HardSoftBigDecimalScore extractScore(int) ,public final Map<java.lang.String,ConstraintMatchTotal<org.optaplanner.core.api.score.buildin.hardsoftbigdecimal.HardSoftBigDecimalScore>> getConstraintMatchTotalMap() ,public final Map<java.lang.Object,Indictment<org.optaplanner.core.api.score.buildin.hardsoftbigdecimal.HardSoftBigDecimalScore>> getIndictmentMap() ,public boolean isConstraintMatchEnabled() <variables>private static final java.lang.String CUSTOM_SCORE_INLINER_CLASS_PROPERTY_NAME,protected final non-sealed boolean constraintMatchEnabled,private final non-sealed Map<java.lang.String,DefaultConstraintMatchTotal<org.optaplanner.core.api.score.buildin.hardsoftbigdecimal.HardSoftBigDecimalScore>> constraintMatchTotalMap,private final non-sealed Map<java.lang.Object,DefaultIndictment<org.optaplanner.core.api.score.buildin.hardsoftbigdecimal.HardSoftBigDecimalScore>> indictmentMap
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-common/src/main/java/org/optaplanner/constraint/streams/common/inliner/HardSoftLongScoreContext.java
|
HardSoftLongScoreContext
|
changeScoreBy
|
class HardSoftLongScoreContext extends ScoreContext<HardSoftLongScore> {
private final LongConsumer softScoreUpdater;
private final LongConsumer hardScoreUpdater;
public HardSoftLongScoreContext(AbstractScoreInliner<HardSoftLongScore> parent, Constraint constraint,
HardSoftLongScore constraintWeight, LongConsumer hardScoreUpdater, LongConsumer softScoreUpdater) {
super(parent, constraint, constraintWeight);
this.softScoreUpdater = softScoreUpdater;
this.hardScoreUpdater = hardScoreUpdater;
}
public UndoScoreImpacter changeSoftScoreBy(long matchWeight, JustificationsSupplier justificationsSupplier) {
long softImpact = constraintWeight.softScore() * matchWeight;
softScoreUpdater.accept(softImpact);
UndoScoreImpacter undoScoreImpact = () -> softScoreUpdater.accept(-softImpact);
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardSoftLongScore.ofSoft(softImpact), justificationsSupplier);
}
public UndoScoreImpacter changeHardScoreBy(long matchWeight, JustificationsSupplier justificationsSupplier) {
long hardImpact = constraintWeight.hardScore() * matchWeight;
hardScoreUpdater.accept(hardImpact);
UndoScoreImpacter undoScoreImpact = () -> hardScoreUpdater.accept(-hardImpact);
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardSoftLongScore.ofHard(hardImpact), justificationsSupplier);
}
public UndoScoreImpacter changeScoreBy(long matchWeight, JustificationsSupplier justificationsSupplier) {<FILL_FUNCTION_BODY>}
}
|
long hardImpact = constraintWeight.hardScore() * matchWeight;
long softImpact = constraintWeight.softScore() * matchWeight;
hardScoreUpdater.accept(hardImpact);
softScoreUpdater.accept(softImpact);
UndoScoreImpacter undoScoreImpact = () -> {
hardScoreUpdater.accept(-hardImpact);
softScoreUpdater.accept(-softImpact);
};
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardSoftLongScore.of(hardImpact, softImpact), justificationsSupplier);
| 485
| 179
| 664
|
<methods>public org.optaplanner.core.api.score.stream.Constraint getConstraint() ,public org.optaplanner.core.api.score.buildin.hardsoftlong.HardSoftLongScore getConstraintWeight() ,public boolean isConstraintMatchEnabled() <variables>protected final non-sealed org.optaplanner.core.api.score.stream.Constraint constraint,protected final non-sealed boolean constraintMatchEnabled,protected final non-sealed org.optaplanner.core.api.score.buildin.hardsoftlong.HardSoftLongScore constraintWeight,private final non-sealed AbstractScoreInliner<org.optaplanner.core.api.score.buildin.hardsoftlong.HardSoftLongScore> parent
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-common/src/main/java/org/optaplanner/constraint/streams/common/inliner/HardSoftLongScoreInliner.java
|
HardSoftLongScoreInliner
|
buildWeightedScoreImpacter
|
class HardSoftLongScoreInliner extends AbstractScoreInliner<HardSoftLongScore> {
private long hardScore;
private long softScore;
HardSoftLongScoreInliner(boolean constraintMatchEnabled) {
super(constraintMatchEnabled);
}
@Override
public WeightedScoreImpacter<HardSoftLongScore, HardSoftLongScoreContext> buildWeightedScoreImpacter(Constraint constraint,
HardSoftLongScore constraintWeight) {<FILL_FUNCTION_BODY>}
@Override
public HardSoftLongScore extractScore(int initScore) {
return HardSoftLongScore.ofUninitialized(initScore, hardScore, softScore);
}
@Override
public String toString() {
return HardSoftLongScore.class.getSimpleName() + " inliner";
}
}
|
validateConstraintWeight(constraint, constraintWeight);
HardSoftLongScoreContext context =
new HardSoftLongScoreContext(this, constraint, constraintWeight,
impact -> this.hardScore += impact, impact -> this.softScore += impact);
if (constraintWeight.softScore() == 0L) {
return WeightedScoreImpacter.of(context,
(HardSoftLongScoreContext ctx, long matchWeight, JustificationsSupplier justificationsSupplier) -> ctx
.changeHardScoreBy(matchWeight, justificationsSupplier));
} else if (constraintWeight.hardScore() == 0L) {
return WeightedScoreImpacter.of(context,
(HardSoftLongScoreContext ctx, long matchWeight, JustificationsSupplier justificationsSupplier) -> ctx
.changeSoftScoreBy(matchWeight, justificationsSupplier));
} else {
return WeightedScoreImpacter.of(context,
(HardSoftLongScoreContext ctx, long matchWeight, JustificationsSupplier justificationsSupplier) -> ctx
.changeScoreBy(matchWeight, justificationsSupplier));
}
| 208
| 268
| 476
|
<methods>public static ScoreInliner_ buildScoreInliner(ScoreDefinition<Score_>, boolean) ,public abstract WeightedScoreImpacter<org.optaplanner.core.api.score.buildin.hardsoftlong.HardSoftLongScore,?> buildWeightedScoreImpacter(org.optaplanner.core.api.score.stream.Constraint, org.optaplanner.core.api.score.buildin.hardsoftlong.HardSoftLongScore) ,public abstract org.optaplanner.core.api.score.buildin.hardsoftlong.HardSoftLongScore extractScore(int) ,public final Map<java.lang.String,ConstraintMatchTotal<org.optaplanner.core.api.score.buildin.hardsoftlong.HardSoftLongScore>> getConstraintMatchTotalMap() ,public final Map<java.lang.Object,Indictment<org.optaplanner.core.api.score.buildin.hardsoftlong.HardSoftLongScore>> getIndictmentMap() ,public boolean isConstraintMatchEnabled() <variables>private static final java.lang.String CUSTOM_SCORE_INLINER_CLASS_PROPERTY_NAME,protected final non-sealed boolean constraintMatchEnabled,private final non-sealed Map<java.lang.String,DefaultConstraintMatchTotal<org.optaplanner.core.api.score.buildin.hardsoftlong.HardSoftLongScore>> constraintMatchTotalMap,private final non-sealed Map<java.lang.Object,DefaultIndictment<org.optaplanner.core.api.score.buildin.hardsoftlong.HardSoftLongScore>> indictmentMap
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-common/src/main/java/org/optaplanner/constraint/streams/common/inliner/HardSoftScoreContext.java
|
HardSoftScoreContext
|
changeScoreBy
|
class HardSoftScoreContext extends ScoreContext<HardSoftScore> {
private final IntConsumer softScoreUpdater;
private final IntConsumer hardScoreUpdater;
public HardSoftScoreContext(AbstractScoreInliner<HardSoftScore> parent, Constraint constraint,
HardSoftScore constraintWeight, IntConsumer hardScoreUpdater, IntConsumer softScoreUpdater) {
super(parent, constraint, constraintWeight);
this.softScoreUpdater = softScoreUpdater;
this.hardScoreUpdater = hardScoreUpdater;
}
public UndoScoreImpacter changeSoftScoreBy(int matchWeight, JustificationsSupplier justificationsSupplier) {
int softImpact = constraintWeight.softScore() * matchWeight;
softScoreUpdater.accept(softImpact);
UndoScoreImpacter undoScoreImpact = () -> softScoreUpdater.accept(-softImpact);
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardSoftScore.ofSoft(softImpact), justificationsSupplier);
}
public UndoScoreImpacter changeHardScoreBy(int matchWeight, JustificationsSupplier justificationsSupplier) {
int hardImpact = constraintWeight.hardScore() * matchWeight;
hardScoreUpdater.accept(hardImpact);
UndoScoreImpacter undoScoreImpact = () -> hardScoreUpdater.accept(-hardImpact);
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardSoftScore.ofHard(hardImpact), justificationsSupplier);
}
public UndoScoreImpacter changeScoreBy(int matchWeight, JustificationsSupplier justificationsSupplier) {<FILL_FUNCTION_BODY>}
}
|
int hardImpact = constraintWeight.hardScore() * matchWeight;
int softImpact = constraintWeight.softScore() * matchWeight;
hardScoreUpdater.accept(hardImpact);
softScoreUpdater.accept(softImpact);
UndoScoreImpacter undoScoreImpact = () -> {
hardScoreUpdater.accept(-hardImpact);
softScoreUpdater.accept(-softImpact);
};
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardSoftScore.of(hardImpact, softImpact), justificationsSupplier);
| 478
| 178
| 656
|
<methods>public org.optaplanner.core.api.score.stream.Constraint getConstraint() ,public org.optaplanner.core.api.score.buildin.hardsoft.HardSoftScore getConstraintWeight() ,public boolean isConstraintMatchEnabled() <variables>protected final non-sealed org.optaplanner.core.api.score.stream.Constraint constraint,protected final non-sealed boolean constraintMatchEnabled,protected final non-sealed org.optaplanner.core.api.score.buildin.hardsoft.HardSoftScore constraintWeight,private final non-sealed AbstractScoreInliner<org.optaplanner.core.api.score.buildin.hardsoft.HardSoftScore> parent
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-common/src/main/java/org/optaplanner/constraint/streams/common/inliner/HardSoftScoreInliner.java
|
HardSoftScoreInliner
|
buildWeightedScoreImpacter
|
class HardSoftScoreInliner extends AbstractScoreInliner<HardSoftScore> {
private int hardScore;
private int softScore;
HardSoftScoreInliner(boolean constraintMatchEnabled) {
super(constraintMatchEnabled);
}
@Override
public WeightedScoreImpacter<HardSoftScore, HardSoftScoreContext> buildWeightedScoreImpacter(Constraint constraint,
HardSoftScore constraintWeight) {<FILL_FUNCTION_BODY>}
@Override
public HardSoftScore extractScore(int initScore) {
return HardSoftScore.ofUninitialized(initScore, hardScore, softScore);
}
@Override
public String toString() {
return HardSoftScore.class.getSimpleName() + " inliner";
}
}
|
validateConstraintWeight(constraint, constraintWeight);
HardSoftScoreContext context = new HardSoftScoreContext(this, constraint, constraintWeight,
impact -> this.hardScore += impact, impact -> this.softScore += impact);
if (constraintWeight.softScore() == 0) {
return WeightedScoreImpacter.of(context, HardSoftScoreContext::changeHardScoreBy);
} else if (constraintWeight.hardScore() == 0) {
return WeightedScoreImpacter.of(context, HardSoftScoreContext::changeSoftScoreBy);
} else {
return WeightedScoreImpacter.of(context, HardSoftScoreContext::changeScoreBy);
}
| 199
| 166
| 365
|
<methods>public static ScoreInliner_ buildScoreInliner(ScoreDefinition<Score_>, boolean) ,public abstract WeightedScoreImpacter<org.optaplanner.core.api.score.buildin.hardsoft.HardSoftScore,?> buildWeightedScoreImpacter(org.optaplanner.core.api.score.stream.Constraint, org.optaplanner.core.api.score.buildin.hardsoft.HardSoftScore) ,public abstract org.optaplanner.core.api.score.buildin.hardsoft.HardSoftScore extractScore(int) ,public final Map<java.lang.String,ConstraintMatchTotal<org.optaplanner.core.api.score.buildin.hardsoft.HardSoftScore>> getConstraintMatchTotalMap() ,public final Map<java.lang.Object,Indictment<org.optaplanner.core.api.score.buildin.hardsoft.HardSoftScore>> getIndictmentMap() ,public boolean isConstraintMatchEnabled() <variables>private static final java.lang.String CUSTOM_SCORE_INLINER_CLASS_PROPERTY_NAME,protected final non-sealed boolean constraintMatchEnabled,private final non-sealed Map<java.lang.String,DefaultConstraintMatchTotal<org.optaplanner.core.api.score.buildin.hardsoft.HardSoftScore>> constraintMatchTotalMap,private final non-sealed Map<java.lang.Object,DefaultIndictment<org.optaplanner.core.api.score.buildin.hardsoft.HardSoftScore>> indictmentMap
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-common/src/main/java/org/optaplanner/constraint/streams/common/inliner/IntWeightedScoreImpacter.java
|
IntWeightedScoreImpacter
|
impactScore
|
class IntWeightedScoreImpacter<Score_ extends Score<Score_>, Context_ extends ScoreContext<Score_>>
implements WeightedScoreImpacter<Score_, Context_> {
private final IntImpactFunction<Score_, Context_> impactFunction;
private final Context_ context;
public IntWeightedScoreImpacter(IntImpactFunction<Score_, Context_> impactFunction, Context_ context) {
this.impactFunction = Objects.requireNonNull(impactFunction);
this.context = context;
}
@Override
public UndoScoreImpacter impactScore(int matchWeight, JustificationsSupplier justificationsSupplier) {
return impactFunction.impact(context, matchWeight, justificationsSupplier);
}
@Override
public UndoScoreImpacter impactScore(long matchWeight, JustificationsSupplier justificationsSupplier) {<FILL_FUNCTION_BODY>}
@Override
public UndoScoreImpacter impactScore(BigDecimal matchWeight, JustificationsSupplier justificationsSupplier) {
throw new UnsupportedOperationException("Impossible state: passing BigDecimal into an int impacter.");
}
@Override
public Context_ getContext() {
return context;
}
}
|
throw new UnsupportedOperationException("Impossible state: passing long into an int impacter.");
| 314
| 24
| 338
|
<no_super_class>
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-common/src/main/java/org/optaplanner/constraint/streams/common/inliner/JustificationsSupplier.java
|
JustificationsSupplier
|
of
|
class JustificationsSupplier {
public static JustificationsSupplier empty() {
return new JustificationsSupplier(DefaultConstraintJustification::of, Collections::emptyList);
}
public static <A> JustificationsSupplier of(Constraint constraint,
BiFunction<A, Score<?>, ConstraintJustification> justificationMapping,
Function<A, Collection<Object>> indictedObjectsMapping,
A a) {
Function<Score<?>, ConstraintJustification> explainingJustificationMapping = impact -> {
try {
return justificationMapping.apply(a, impact);
} catch (Exception e) {
throw createJustificationException(constraint, e, a);
}
};
Supplier<Collection<Object>> explainingIndictedObjectsSupplier = () -> {
try {
return indictedObjectsMapping.apply(a);
} catch (Exception e) {
throw createIndictmentException(constraint, e, a);
}
};
return new JustificationsSupplier(explainingJustificationMapping, explainingIndictedObjectsSupplier);
}
private static RuntimeException createJustificationException(Constraint constraint, Exception cause, Object... facts) {
throw new IllegalStateException("Consequence of a constraint (" + constraint.getConstraintId()
+ ") threw an exception creating constraint justification from a tuple (" + factsToString(facts) + ").", cause);
}
private static String factsToString(Object... facts) {
return Arrays.stream(facts)
.map(Object::toString)
.collect(Collectors.joining(", ", "{", "}"));
}
private static RuntimeException createIndictmentException(Constraint constraint, Exception cause, Object... facts) {
throw new IllegalStateException("Consequence of a constraint (" + constraint.getConstraintId()
+ ") threw an exception collecting indicted objects from a tuple (" + factsToString(facts) + ").", cause);
}
public static <A, B> JustificationsSupplier of(Constraint constraint,
TriFunction<A, B, Score<?>, ConstraintJustification> justificationMapping,
BiFunction<A, B, Collection<Object>> indictedObjectsMapping,
A a, B b) {
Function<Score<?>, ConstraintJustification> explainingJustificationMapping = impact -> {
try {
return justificationMapping.apply(a, b, impact);
} catch (Exception e) {
throw createJustificationException(constraint, e, a, b);
}
};
Supplier<Collection<Object>> explainingIndictedObjectsSupplier = () -> {
try {
return indictedObjectsMapping.apply(a, b);
} catch (Exception e) {
throw createIndictmentException(constraint, e, a, b);
}
};
return new JustificationsSupplier(explainingJustificationMapping, explainingIndictedObjectsSupplier);
}
public static <A, B, C> JustificationsSupplier of(Constraint constraint,
QuadFunction<A, B, C, Score<?>, ConstraintJustification> justificationMapping,
TriFunction<A, B, C, Collection<Object>> indictedObjectsMapping,
A a, B b, C c) {<FILL_FUNCTION_BODY>}
public static <A, B, C, D> JustificationsSupplier of(Constraint constraint,
PentaFunction<A, B, C, D, Score<?>, ConstraintJustification> justificationMapping,
QuadFunction<A, B, C, D, Collection<Object>> indictedObjectsMapping,
A a, B b, C c, D d) {
Function<Score<?>, ConstraintJustification> explainingJustificationMapping = impact -> {
try {
return justificationMapping.apply(a, b, c, d, impact);
} catch (Exception e) {
throw createJustificationException(constraint, e, a, b, c, d);
}
};
Supplier<Collection<Object>> explainingIndictedObjectsSupplier = () -> {
try {
return indictedObjectsMapping.apply(a, b, c, d);
} catch (Exception e) {
throw createIndictmentException(constraint, e, a, b, c, d);
}
};
return new JustificationsSupplier(explainingJustificationMapping, explainingIndictedObjectsSupplier);
}
private final Function<Score<?>, ConstraintJustification> constraintJustificationSupplier;
private final Supplier<Collection<Object>> indictedObjectsSupplier;
private JustificationsSupplier(Function<Score<?>, ConstraintJustification> constraintJustificationSupplier,
Supplier<Collection<Object>> indictedObjectsSupplier) {
this.constraintJustificationSupplier = Objects.requireNonNull(constraintJustificationSupplier);
this.indictedObjectsSupplier = Objects.requireNonNull(indictedObjectsSupplier);
}
public ConstraintJustification createConstraintJustification(Score<?> impact) {
return constraintJustificationSupplier.apply(impact);
}
public Collection<Object> createIndictedObjects() {
return indictedObjectsSupplier.get();
}
}
|
Function<Score<?>, ConstraintJustification> explainingJustificationMapping = impact -> {
try {
return justificationMapping.apply(a, b, c, impact);
} catch (Exception e) {
throw createJustificationException(constraint, e, a, b, c);
}
};
Supplier<Collection<Object>> explainingIndictedObjectsSupplier = () -> {
try {
return indictedObjectsMapping.apply(a, b, c);
} catch (Exception e) {
throw createIndictmentException(constraint, e, a, b, c);
}
};
return new JustificationsSupplier(explainingJustificationMapping, explainingIndictedObjectsSupplier);
| 1,275
| 176
| 1,451
|
<no_super_class>
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-common/src/main/java/org/optaplanner/constraint/streams/common/inliner/LongWeightedScoreImpacter.java
|
LongWeightedScoreImpacter
|
impactScore
|
class LongWeightedScoreImpacter<Score_ extends Score<Score_>, Context_ extends ScoreContext<Score_>>
implements WeightedScoreImpacter<Score_, Context_> {
private final LongImpactFunction<Score_, Context_> impactFunction;
private final Context_ context;
public LongWeightedScoreImpacter(LongImpactFunction<Score_, Context_> impactFunction, Context_ context) {
this.impactFunction = Objects.requireNonNull(impactFunction);
this.context = context;
}
@Override
public UndoScoreImpacter impactScore(int matchWeight, JustificationsSupplier justificationsSupplier) {
return impactFunction.impact(context, matchWeight, justificationsSupplier); // int can be cast to long
}
@Override
public UndoScoreImpacter impactScore(long matchWeight, JustificationsSupplier justificationsSupplier) {
return impactFunction.impact(context, matchWeight, justificationsSupplier);
}
@Override
public UndoScoreImpacter impactScore(BigDecimal matchWeight, JustificationsSupplier justificationsSupplier) {<FILL_FUNCTION_BODY>}
@Override
public Context_ getContext() {
return context;
}
}
|
throw new UnsupportedOperationException("Impossible state: passing BigDecimal into a long impacter.");
| 317
| 26
| 343
|
<no_super_class>
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-common/src/main/java/org/optaplanner/constraint/streams/common/inliner/ScoreContext.java
|
ScoreContext
|
impactWithConstraintMatch
|
class ScoreContext<Score_ extends Score<Score_>> {
private final AbstractScoreInliner<Score_> parent;
protected final Constraint constraint;
protected final Score_ constraintWeight;
protected final boolean constraintMatchEnabled;
protected ScoreContext(AbstractScoreInliner<Score_> parent, Constraint constraint, Score_ constraintWeight) {
this.parent = parent;
this.constraint = constraint;
this.constraintWeight = constraintWeight;
this.constraintMatchEnabled = parent.constraintMatchEnabled;
}
public Constraint getConstraint() {
return constraint;
}
public Score_ getConstraintWeight() {
return constraintWeight;
}
public boolean isConstraintMatchEnabled() {
return constraintMatchEnabled;
}
protected UndoScoreImpacter impactWithConstraintMatch(UndoScoreImpacter undoScoreImpact, Score_ score,
JustificationsSupplier justificationsSupplier) {<FILL_FUNCTION_BODY>}
}
|
Runnable undoConstraintMatch = parent.addConstraintMatch(constraint, constraintWeight, score, justificationsSupplier);
return () -> {
undoScoreImpact.run();
undoConstraintMatch.run();
};
| 253
| 61
| 314
|
<no_super_class>
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-common/src/main/java/org/optaplanner/constraint/streams/common/inliner/SimpleBigDecimalScoreContext.java
|
SimpleBigDecimalScoreContext
|
changeScoreBy
|
class SimpleBigDecimalScoreContext extends ScoreContext<SimpleBigDecimalScore> {
private final Consumer<BigDecimal> scoreUpdater;
public SimpleBigDecimalScoreContext(AbstractScoreInliner<SimpleBigDecimalScore> parent, Constraint constraint,
SimpleBigDecimalScore constraintWeight, Consumer<BigDecimal> scoreUpdater) {
super(parent, constraint, constraintWeight);
this.scoreUpdater = scoreUpdater;
}
public UndoScoreImpacter changeScoreBy(BigDecimal matchWeight, JustificationsSupplier justificationsSupplier) {<FILL_FUNCTION_BODY>}
}
|
BigDecimal impact = constraintWeight.score().multiply(matchWeight);
scoreUpdater.accept(impact);
UndoScoreImpacter undoScoreImpact = () -> scoreUpdater.accept(impact.negate());
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, SimpleBigDecimalScore.of(impact), justificationsSupplier);
| 162
| 117
| 279
|
<methods>public org.optaplanner.core.api.score.stream.Constraint getConstraint() ,public org.optaplanner.core.api.score.buildin.simplebigdecimal.SimpleBigDecimalScore getConstraintWeight() ,public boolean isConstraintMatchEnabled() <variables>protected final non-sealed org.optaplanner.core.api.score.stream.Constraint constraint,protected final non-sealed boolean constraintMatchEnabled,protected final non-sealed org.optaplanner.core.api.score.buildin.simplebigdecimal.SimpleBigDecimalScore constraintWeight,private final non-sealed AbstractScoreInliner<org.optaplanner.core.api.score.buildin.simplebigdecimal.SimpleBigDecimalScore> parent
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-common/src/main/java/org/optaplanner/constraint/streams/common/inliner/SimpleBigDecimalScoreInliner.java
|
SimpleBigDecimalScoreInliner
|
buildWeightedScoreImpacter
|
class SimpleBigDecimalScoreInliner extends AbstractScoreInliner<SimpleBigDecimalScore> {
private BigDecimal score = BigDecimal.ZERO;
SimpleBigDecimalScoreInliner(boolean constraintMatchEnabled) {
super(constraintMatchEnabled);
}
@Override
public WeightedScoreImpacter<SimpleBigDecimalScore, SimpleBigDecimalScoreContext> buildWeightedScoreImpacter(
Constraint constraint, SimpleBigDecimalScore constraintWeight) {<FILL_FUNCTION_BODY>}
@Override
public SimpleBigDecimalScore extractScore(int initScore) {
return SimpleBigDecimalScore.ofUninitialized(initScore, score);
}
@Override
public String toString() {
return SimpleBigDecimalScore.class.getSimpleName() + " inliner";
}
}
|
validateConstraintWeight(constraint, constraintWeight);
SimpleBigDecimalScoreContext context = new SimpleBigDecimalScoreContext(this, constraint, constraintWeight,
impact -> this.score = this.score.add(impact));
return WeightedScoreImpacter.of(context, SimpleBigDecimalScoreContext::changeScoreBy);
| 216
| 82
| 298
|
<methods>public static ScoreInliner_ buildScoreInliner(ScoreDefinition<Score_>, boolean) ,public abstract WeightedScoreImpacter<org.optaplanner.core.api.score.buildin.simplebigdecimal.SimpleBigDecimalScore,?> buildWeightedScoreImpacter(org.optaplanner.core.api.score.stream.Constraint, org.optaplanner.core.api.score.buildin.simplebigdecimal.SimpleBigDecimalScore) ,public abstract org.optaplanner.core.api.score.buildin.simplebigdecimal.SimpleBigDecimalScore extractScore(int) ,public final Map<java.lang.String,ConstraintMatchTotal<org.optaplanner.core.api.score.buildin.simplebigdecimal.SimpleBigDecimalScore>> getConstraintMatchTotalMap() ,public final Map<java.lang.Object,Indictment<org.optaplanner.core.api.score.buildin.simplebigdecimal.SimpleBigDecimalScore>> getIndictmentMap() ,public boolean isConstraintMatchEnabled() <variables>private static final java.lang.String CUSTOM_SCORE_INLINER_CLASS_PROPERTY_NAME,protected final non-sealed boolean constraintMatchEnabled,private final non-sealed Map<java.lang.String,DefaultConstraintMatchTotal<org.optaplanner.core.api.score.buildin.simplebigdecimal.SimpleBigDecimalScore>> constraintMatchTotalMap,private final non-sealed Map<java.lang.Object,DefaultIndictment<org.optaplanner.core.api.score.buildin.simplebigdecimal.SimpleBigDecimalScore>> indictmentMap
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-common/src/main/java/org/optaplanner/constraint/streams/common/inliner/SimpleLongScoreContext.java
|
SimpleLongScoreContext
|
changeScoreBy
|
class SimpleLongScoreContext extends ScoreContext<SimpleLongScore> {
private final LongConsumer scoreUpdater;
public SimpleLongScoreContext(AbstractScoreInliner<SimpleLongScore> parent, Constraint constraint,
SimpleLongScore constraintWeight, LongConsumer scoreUpdater) {
super(parent, constraint, constraintWeight);
this.scoreUpdater = scoreUpdater;
}
public UndoScoreImpacter changeScoreBy(long matchWeight, JustificationsSupplier justificationsSupplier) {<FILL_FUNCTION_BODY>}
}
|
long impact = constraintWeight.score() * matchWeight;
scoreUpdater.accept(impact);
UndoScoreImpacter undoScoreImpact = () -> scoreUpdater.accept(-impact);
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, SimpleLongScore.of(impact), justificationsSupplier);
| 140
| 107
| 247
|
<methods>public org.optaplanner.core.api.score.stream.Constraint getConstraint() ,public org.optaplanner.core.api.score.buildin.simplelong.SimpleLongScore getConstraintWeight() ,public boolean isConstraintMatchEnabled() <variables>protected final non-sealed org.optaplanner.core.api.score.stream.Constraint constraint,protected final non-sealed boolean constraintMatchEnabled,protected final non-sealed org.optaplanner.core.api.score.buildin.simplelong.SimpleLongScore constraintWeight,private final non-sealed AbstractScoreInliner<org.optaplanner.core.api.score.buildin.simplelong.SimpleLongScore> parent
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-common/src/main/java/org/optaplanner/constraint/streams/common/inliner/SimpleLongScoreInliner.java
|
SimpleLongScoreInliner
|
buildWeightedScoreImpacter
|
class SimpleLongScoreInliner extends AbstractScoreInliner<SimpleLongScore> {
private long score;
SimpleLongScoreInliner(boolean constraintMatchEnabled) {
super(constraintMatchEnabled);
}
@Override
public WeightedScoreImpacter<SimpleLongScore, SimpleLongScoreContext> buildWeightedScoreImpacter(Constraint constraint,
SimpleLongScore constraintWeight) {<FILL_FUNCTION_BODY>}
@Override
public SimpleLongScore extractScore(int initScore) {
return SimpleLongScore.ofUninitialized(initScore, score);
}
@Override
public String toString() {
return SimpleLongScore.class.getSimpleName() + " inliner";
}
}
|
validateConstraintWeight(constraint, constraintWeight);
SimpleLongScoreContext context = new SimpleLongScoreContext(this, constraint, constraintWeight,
impact -> this.score += impact);
return WeightedScoreImpacter.of(context,
(SimpleLongScoreContext ctx, long matchWeight, JustificationsSupplier justificationsSupplier) -> ctx
.changeScoreBy(matchWeight, justificationsSupplier));
| 187
| 100
| 287
|
<methods>public static ScoreInliner_ buildScoreInliner(ScoreDefinition<Score_>, boolean) ,public abstract WeightedScoreImpacter<org.optaplanner.core.api.score.buildin.simplelong.SimpleLongScore,?> buildWeightedScoreImpacter(org.optaplanner.core.api.score.stream.Constraint, org.optaplanner.core.api.score.buildin.simplelong.SimpleLongScore) ,public abstract org.optaplanner.core.api.score.buildin.simplelong.SimpleLongScore extractScore(int) ,public final Map<java.lang.String,ConstraintMatchTotal<org.optaplanner.core.api.score.buildin.simplelong.SimpleLongScore>> getConstraintMatchTotalMap() ,public final Map<java.lang.Object,Indictment<org.optaplanner.core.api.score.buildin.simplelong.SimpleLongScore>> getIndictmentMap() ,public boolean isConstraintMatchEnabled() <variables>private static final java.lang.String CUSTOM_SCORE_INLINER_CLASS_PROPERTY_NAME,protected final non-sealed boolean constraintMatchEnabled,private final non-sealed Map<java.lang.String,DefaultConstraintMatchTotal<org.optaplanner.core.api.score.buildin.simplelong.SimpleLongScore>> constraintMatchTotalMap,private final non-sealed Map<java.lang.Object,DefaultIndictment<org.optaplanner.core.api.score.buildin.simplelong.SimpleLongScore>> indictmentMap
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-common/src/main/java/org/optaplanner/constraint/streams/common/penta/FilteringPentaJoiner.java
|
FilteringPentaJoiner
|
equals
|
class FilteringPentaJoiner<A, B, C, D, E> implements PentaJoiner<A, B, C, D, E> {
private final PentaPredicate<A, B, C, D, E> filter;
public FilteringPentaJoiner(PentaPredicate<A, B, C, D, E> filter) {
this.filter = filter;
}
@Override
public FilteringPentaJoiner<A, B, C, D, E> and(PentaJoiner<A, B, C, D, E> otherJoiner) {
FilteringPentaJoiner<A, B, C, D, E> castJoiner = (FilteringPentaJoiner<A, B, C, D, E>) otherJoiner;
return new FilteringPentaJoiner<>(filter.and(castJoiner.getFilter()));
}
public PentaPredicate<A, B, C, D, E> getFilter() {
return filter;
}
@Override
public boolean equals(Object o) {<FILL_FUNCTION_BODY>}
@Override
public int hashCode() {
return Objects.hash(filter);
}
}
|
if (this == o) {
return true;
}
if (!(o instanceof FilteringPentaJoiner)) {
return false;
}
FilteringPentaJoiner<?, ?, ?, ?, ?> other = (FilteringPentaJoiner<?, ?, ?, ?, ?>) o;
return Objects.equals(filter, other.filter);
| 303
| 97
| 400
|
<no_super_class>
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-common/src/main/java/org/optaplanner/constraint/streams/common/penta/PentaJoinerComber.java
|
PentaJoinerComber
|
comb
|
class PentaJoinerComber<A, B, C, D, E> {
public static <A, B, C, D, E> PentaJoinerComber<A, B, C, D, E> comb(PentaJoiner<A, B, C, D, E>[] joiners) {<FILL_FUNCTION_BODY>}
private static <A, B, C, D, E> PentaPredicate<A, B, C, D, E>
mergeFiltering(List<PentaPredicate<A, B, C, D, E>> filteringList) {
if (filteringList.isEmpty()) {
return null;
}
switch (filteringList.size()) {
case 1:
return filteringList.get(0);
case 2:
return filteringList.get(0).and(filteringList.get(1));
default:
// Avoid predicate.and() when more than 2 predicates for debugging and potentially performance
return (A a, B b, C c, D d, E e) -> {
for (PentaPredicate<A, B, C, D, E> predicate : filteringList) {
if (!predicate.test(a, b, c, d, e)) {
return false;
}
}
return true;
};
}
}
private final DefaultPentaJoiner<A, B, C, D, E> mergedJoiner;
private final PentaPredicate<A, B, C, D, E> mergedFiltering;
public PentaJoinerComber(DefaultPentaJoiner<A, B, C, D, E> mergedJoiner, PentaPredicate<A, B, C, D, E> mergedFiltering) {
this.mergedJoiner = mergedJoiner;
this.mergedFiltering = mergedFiltering;
}
/**
* @return never null
*/
public DefaultPentaJoiner<A, B, C, D, E> getMergedJoiner() {
return mergedJoiner;
}
/**
* @return null if not applicable
*/
public PentaPredicate<A, B, C, D, E> getMergedFiltering() {
return mergedFiltering;
}
}
|
List<DefaultPentaJoiner<A, B, C, D, E>> defaultJoinerList = new ArrayList<>(joiners.length);
List<PentaPredicate<A, B, C, D, E>> filteringList = new ArrayList<>(joiners.length);
int indexOfFirstFilter = -1;
// Make sure all indexing joiners, if any, come before filtering joiners. This is necessary for performance.
for (int i = 0; i < joiners.length; i++) {
PentaJoiner<A, B, C, D, E> joiner = joiners[i];
if (joiner instanceof FilteringPentaJoiner) {
// From now on, only allow filtering joiners.
indexOfFirstFilter = i;
filteringList.add(((FilteringPentaJoiner<A, B, C, D, E>) joiner).getFilter());
} else if (joiner instanceof DefaultPentaJoiner) {
if (indexOfFirstFilter >= 0) {
throw new IllegalStateException("Indexing joiner (" + joiner + ") must not follow " +
"a filtering joiner (" + joiners[indexOfFirstFilter] + ").\n" +
"Maybe reorder the joiners such that filtering() joiners are later in the parameter list.");
}
defaultJoinerList.add((DefaultPentaJoiner<A, B, C, D, E>) joiner);
} else {
throw new IllegalArgumentException("The joiner class (" + joiner.getClass() + ") is not supported.");
}
}
DefaultPentaJoiner<A, B, C, D, E> mergedJoiner = DefaultPentaJoiner.merge(defaultJoinerList);
PentaPredicate<A, B, C, D, E> mergedFiltering = mergeFiltering(filteringList);
return new PentaJoinerComber<>(mergedJoiner, mergedFiltering);
| 570
| 468
| 1,038
|
<no_super_class>
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-common/src/main/java/org/optaplanner/constraint/streams/common/quad/QuadConstraintBuilderImpl.java
|
QuadConstraintBuilderImpl
|
indictWith
|
class QuadConstraintBuilderImpl<A, B, C, D, Score_ extends Score<Score_>>
extends AbstractConstraintBuilder<Score_>
implements QuadConstraintBuilder<A, B, C, D, Score_> {
private PentaFunction<A, B, C, D, Score_, ConstraintJustification> justificationMapping;
private QuadFunction<A, B, C, D, Collection<Object>> indictedObjectsMapping;
public QuadConstraintBuilderImpl(QuadConstraintConstructor<A, B, C, D, Score_> constraintConstructor,
ScoreImpactType impactType, Score_ constraintWeight) {
super(constraintConstructor, impactType, constraintWeight);
}
@Override
protected PentaFunction<A, B, C, D, Score_, ConstraintJustification> getJustificationMapping() {
return justificationMapping;
}
@Override
public <ConstraintJustification_ extends ConstraintJustification> QuadConstraintBuilder<A, B, C, D, Score_> justifyWith(
PentaFunction<A, B, C, D, Score_, ConstraintJustification_> justificationMapping) {
if (this.justificationMapping != null) {
throw new IllegalStateException("Justification mapping already set (" + justificationMapping + ").");
}
this.justificationMapping =
(PentaFunction<A, B, C, D, Score_, ConstraintJustification>) Objects.requireNonNull(justificationMapping);
return this;
}
@Override
protected QuadFunction<A, B, C, D, Collection<Object>> getIndictedObjectsMapping() {
return indictedObjectsMapping;
}
@Override
public QuadConstraintBuilder<A, B, C, D, Score_>
indictWith(QuadFunction<A, B, C, D, Collection<Object>> indictedObjectsMapping) {<FILL_FUNCTION_BODY>}
}
|
if (this.indictedObjectsMapping != null) {
throw new IllegalStateException("Indicted objects' mapping already set (" + indictedObjectsMapping + ").");
}
this.indictedObjectsMapping = Objects.requireNonNull(indictedObjectsMapping);
return this;
| 484
| 72
| 556
|
<methods>public final org.optaplanner.core.api.score.stream.Constraint asConstraint(java.lang.String) ,public final org.optaplanner.core.api.score.stream.Constraint asConstraint(java.lang.String, java.lang.String) <variables>private final non-sealed ConstraintConstructor#RAW constraintConstructor,private final non-sealed Score_ constraintWeight,private final non-sealed org.optaplanner.constraint.streams.common.ScoreImpactType impactType
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-common/src/main/java/org/optaplanner/constraint/streams/common/quad/QuadJoinerComber.java
|
QuadJoinerComber
|
comb
|
class QuadJoinerComber<A, B, C, D> {
public static <A, B, C, D> QuadJoinerComber<A, B, C, D> comb(QuadJoiner<A, B, C, D>[] joiners) {<FILL_FUNCTION_BODY>}
private static <A, B, C, D> QuadPredicate<A, B, C, D> mergeFiltering(List<QuadPredicate<A, B, C, D>> filteringList) {
if (filteringList.isEmpty()) {
return null;
}
switch (filteringList.size()) {
case 1:
return filteringList.get(0);
case 2:
return filteringList.get(0).and(filteringList.get(1));
default:
// Avoid predicate.and() when more than 2 predicates for debugging and potentially performance
return (A a, B b, C c, D d) -> {
for (QuadPredicate<A, B, C, D> predicate : filteringList) {
if (!predicate.test(a, b, c, d)) {
return false;
}
}
return true;
};
}
}
private final DefaultQuadJoiner<A, B, C, D> mergedJoiner;
private final QuadPredicate<A, B, C, D> mergedFiltering;
public QuadJoinerComber(DefaultQuadJoiner<A, B, C, D> mergedJoiner, QuadPredicate<A, B, C, D> mergedFiltering) {
this.mergedJoiner = mergedJoiner;
this.mergedFiltering = mergedFiltering;
}
/**
* @return never null
*/
public DefaultQuadJoiner<A, B, C, D> getMergedJoiner() {
return mergedJoiner;
}
/**
* @return null if not applicable
*/
public QuadPredicate<A, B, C, D> getMergedFiltering() {
return mergedFiltering;
}
}
|
List<DefaultQuadJoiner<A, B, C, D>> defaultJoinerList = new ArrayList<>(joiners.length);
List<QuadPredicate<A, B, C, D>> filteringList = new ArrayList<>(joiners.length);
int indexOfFirstFilter = -1;
// Make sure all indexing joiners, if any, come before filtering joiners. This is necessary for performance.
for (int i = 0; i < joiners.length; i++) {
QuadJoiner<A, B, C, D> joiner = joiners[i];
if (joiner instanceof FilteringQuadJoiner) {
// From now on, only allow filtering joiners.
indexOfFirstFilter = i;
filteringList.add(((FilteringQuadJoiner<A, B, C, D>) joiner).getFilter());
} else if (joiner instanceof DefaultQuadJoiner) {
if (indexOfFirstFilter >= 0) {
throw new IllegalStateException("Indexing joiner (" + joiner + ") must not follow " +
"a filtering joiner (" + joiners[indexOfFirstFilter] + ").\n" +
"Maybe reorder the joiners such that filtering() joiners are later in the parameter list.");
}
defaultJoinerList.add((DefaultQuadJoiner<A, B, C, D>) joiner);
} else {
throw new IllegalArgumentException("The joiner class (" + joiner.getClass() + ") is not supported.");
}
}
DefaultQuadJoiner<A, B, C, D> mergedJoiner = DefaultQuadJoiner.merge(defaultJoinerList);
QuadPredicate<A, B, C, D> mergedFiltering = mergeFiltering(filteringList);
return new QuadJoinerComber<>(mergedJoiner, mergedFiltering);
| 535
| 454
| 989
|
<no_super_class>
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-common/src/main/java/org/optaplanner/constraint/streams/common/tri/TriConstraintBuilderImpl.java
|
TriConstraintBuilderImpl
|
indictWith
|
class TriConstraintBuilderImpl<A, B, C, Score_ extends Score<Score_>>
extends AbstractConstraintBuilder<Score_>
implements TriConstraintBuilder<A, B, C, Score_> {
private QuadFunction<A, B, C, Score_, ConstraintJustification> justificationMapping;
private TriFunction<A, B, C, Collection<Object>> indictedObjectsMapping;
public TriConstraintBuilderImpl(TriConstraintConstructor<A, B, C, Score_> constraintConstructor, ScoreImpactType impactType,
Score_ constraintWeight) {
super(constraintConstructor, impactType, constraintWeight);
}
@Override
protected QuadFunction<A, B, C, Score_, ConstraintJustification> getJustificationMapping() {
return justificationMapping;
}
@Override
public <ConstraintJustification_ extends ConstraintJustification> TriConstraintBuilder<A, B, C, Score_> justifyWith(
QuadFunction<A, B, C, Score_, ConstraintJustification_> justificationMapping) {
if (this.justificationMapping != null) {
throw new IllegalStateException("Justification mapping already set (" + justificationMapping + ").");
}
this.justificationMapping =
(QuadFunction<A, B, C, Score_, ConstraintJustification>) Objects.requireNonNull(justificationMapping);
return this;
}
@Override
protected TriFunction<A, B, C, Collection<Object>> getIndictedObjectsMapping() {
return indictedObjectsMapping;
}
@Override
public TriConstraintBuilder<A, B, C, Score_> indictWith(TriFunction<A, B, C, Collection<Object>> indictedObjectsMapping) {<FILL_FUNCTION_BODY>}
}
|
if (this.indictedObjectsMapping != null) {
throw new IllegalStateException("Indicted objects' mapping already set (" + indictedObjectsMapping + ").");
}
this.indictedObjectsMapping = Objects.requireNonNull(indictedObjectsMapping);
return this;
| 449
| 72
| 521
|
<methods>public final org.optaplanner.core.api.score.stream.Constraint asConstraint(java.lang.String) ,public final org.optaplanner.core.api.score.stream.Constraint asConstraint(java.lang.String, java.lang.String) <variables>private final non-sealed ConstraintConstructor#RAW constraintConstructor,private final non-sealed Score_ constraintWeight,private final non-sealed org.optaplanner.constraint.streams.common.ScoreImpactType impactType
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-common/src/main/java/org/optaplanner/constraint/streams/common/uni/UniConstraintBuilderImpl.java
|
UniConstraintBuilderImpl
|
justifyWith
|
class UniConstraintBuilderImpl<A, Score_ extends Score<Score_>>
extends AbstractConstraintBuilder<Score_>
implements UniConstraintBuilder<A, Score_> {
private BiFunction<A, Score_, ConstraintJustification> justificationMapping;
private Function<A, Collection<Object>> indictedObjectsMapping;
public UniConstraintBuilderImpl(UniConstraintConstructor<A, Score_> constraintConstructor, ScoreImpactType impactType,
Score_ constraintWeight) {
super(constraintConstructor, impactType, constraintWeight);
}
@Override
protected BiFunction<A, Score_, ConstraintJustification> getJustificationMapping() {
return justificationMapping;
}
@Override
public <ConstraintJustification_ extends ConstraintJustification> UniConstraintBuilder<A, Score_> justifyWith(
BiFunction<A, Score_, ConstraintJustification_> justificationMapping) {<FILL_FUNCTION_BODY>}
@Override
protected Function<A, Collection<Object>> getIndictedObjectsMapping() {
return indictedObjectsMapping;
}
@Override
public UniConstraintBuilder<A, Score_> indictWith(Function<A, Collection<Object>> indictedObjectsMapping) {
if (this.indictedObjectsMapping != null) {
throw new IllegalStateException("Indicted objects' mapping already set (" + indictedObjectsMapping + ").");
}
this.indictedObjectsMapping = Objects.requireNonNull(indictedObjectsMapping);
return this;
}
}
|
if (this.justificationMapping != null) {
throw new IllegalStateException("Justification mapping already set (" + justificationMapping + ").");
}
this.justificationMapping =
(BiFunction<A, Score_, ConstraintJustification>) Objects.requireNonNull(justificationMapping);
return this;
| 389
| 83
| 472
|
<methods>public final org.optaplanner.core.api.score.stream.Constraint asConstraint(java.lang.String) ,public final org.optaplanner.core.api.score.stream.Constraint asConstraint(java.lang.String, java.lang.String) <variables>private final non-sealed ConstraintConstructor#RAW constraintConstructor,private final non-sealed Score_ constraintWeight,private final non-sealed org.optaplanner.constraint.streams.common.ScoreImpactType impactType
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-drools/src/main/java/org/optaplanner/constraint/streams/drools/DroolsConstraintStreamScoreDirectorFactory.java
|
DroolsConstraintStreamScoreDirectorFactory
|
buildKieBaseFromModel
|
class DroolsConstraintStreamScoreDirectorFactory<Solution_, Score_ extends Score<Score_>>
extends AbstractConstraintStreamScoreDirectorFactory<Solution_, Score_> {
private final KieBaseDescriptor<Solution_> kieBaseDescriptor;
private final boolean droolsAlphaNetworkCompilationEnabled;
public DroolsConstraintStreamScoreDirectorFactory(SolutionDescriptor<Solution_> solutionDescriptor,
ConstraintProvider constraintProvider, boolean droolsAlphaNetworkCompilationEnabled) {
this(solutionDescriptor,
buildKieBase(solutionDescriptor, constraintProvider, droolsAlphaNetworkCompilationEnabled),
droolsAlphaNetworkCompilationEnabled);
}
@SuppressWarnings("unchecked")
public DroolsConstraintStreamScoreDirectorFactory(SolutionDescriptor<Solution_> solutionDescriptor,
KieBaseDescriptor<Solution_> kieBaseDescriptor, boolean droolsAlphaNetworkCompilationEnabled) {
super(solutionDescriptor);
this.kieBaseDescriptor = Objects.requireNonNull(kieBaseDescriptor);
this.droolsAlphaNetworkCompilationEnabled = droolsAlphaNetworkCompilationEnabled;
}
@Override
public DroolsConstraintStreamScoreDirector<Solution_, Score_> buildScoreDirector(boolean lookUpEnabled,
boolean constraintMatchEnabledPreference) {
return new DroolsConstraintStreamScoreDirector<>(this, lookUpEnabled, constraintMatchEnabledPreference);
}
public static <Solution_> KieBaseDescriptor<Solution_> buildKieBase(SolutionDescriptor<Solution_> solutionDescriptor,
ConstraintProvider constraintProvider, boolean droolsAlphaNetworkCompilationEnabled) {
List<DroolsConstraint<Solution_>> constraints = new DroolsConstraintFactory<>(solutionDescriptor)
.buildConstraints(constraintProvider);
// Each constraint gets its own global, in which it will keep its impacter.
// Impacters carry constraint weights, and therefore the instances are solution-specific.
AtomicInteger idCounter = new AtomicInteger(0);
Map<DroolsConstraint<Solution_>, Global<WeightedScoreImpacter>> constraintToGlobalMap = constraints.stream()
.collect(toMap(Function.identity(),
c -> globalOf(WeightedScoreImpacter.class, c.getConstraintPackage(),
"scoreImpacter" + idCounter.getAndIncrement())));
ModelImpl model = constraints.stream()
.map(constraint -> constraint.buildRule(constraintToGlobalMap.get(constraint)))
.reduce(new ModelImpl(), ModelImpl::addRule, (m, key) -> m);
constraintToGlobalMap.forEach((constraint, global) -> model.addGlobal(global));
KieBase kieBase = buildKieBaseFromModel(model, droolsAlphaNetworkCompilationEnabled);
return new KieBaseDescriptor<>(constraintToGlobalMap, kieBase);
}
private static KieBase buildKieBaseFromModel(Model model, boolean droolsAlphaNetworkCompilationEnabled) {<FILL_FUNCTION_BODY>}
public SessionDescriptor<Score_> newSession(boolean constraintMatchEnabled, Solution_ workingSolution) {
// Extract constraint weights.
Map<DroolsConstraint<Solution_>, Score_> constraintToWeightMap = kieBaseDescriptor.getConstraintToGlobalMap()
.keySet()
.stream()
.collect(toMap(Function.identity(), constraint -> constraint.extractConstraintWeight(workingSolution)));
// Create the session itself.
KieSession kieSession = buildKieSessionFromKieBase(kieBaseDescriptor.get());
((RuleEventManager) kieSession).addEventListener(new OptaPlannerRuleEventListener()); // Enables undo in rules.
// Build and set the impacters for each constraint; this locks in the constraint weights.
ScoreDefinition<Score_> scoreDefinition = solutionDescriptor.getScoreDefinition();
AbstractScoreInliner<Score_> scoreInliner = AbstractScoreInliner.buildScoreInliner(scoreDefinition,
constraintMatchEnabled);
Set<String> disabledConstraints = new HashSet<>();
for (Map.Entry<DroolsConstraint<Solution_>, Score_> entry : constraintToWeightMap.entrySet()) {
DroolsConstraint<Solution_> constraint = entry.getKey();
Score_ constraintWeight = entry.getValue();
if (constraintWeight.isZero()) {
disabledConstraints.add(constraint.getConstraintId());
} else {
String globalName = kieBaseDescriptor.getConstraintToGlobalMap().get(constraint).getName();
kieSession.setGlobal(globalName, scoreInliner.buildWeightedScoreImpacter(constraint, constraintWeight));
}
}
// Return only the inliner as that holds the work product of the individual impacters.
AgendaFilter agendaFilter =
disabledConstraints.isEmpty() ? null : new ConstraintDisablingAgendaFilter(Set.copyOf(disabledConstraints));
return new SessionDescriptor<>(kieSession, scoreInliner, agendaFilter);
}
@Override
public SolutionDescriptor<Solution_> getSolutionDescriptor() {
return solutionDescriptor;
}
private static KieSession buildKieSessionFromKieBase(KieBase kieBase) {
KieSessionConfiguration config = KieServices.get().newKieSessionConfiguration();
config.setOption(DirectFiringOption.YES); // For performance; not applicable to DRL due to insertLogical etc.
return kieBase.newKieSession(config, null);
}
@Override
public AbstractScoreInliner<Score_> fireAndForget(Object... facts) {
SessionDescriptor<Score_> sessionDescriptor = newSession(true, null);
KieSession session = sessionDescriptor.getSession();
try {
Arrays.stream(facts).forEach(session::insert);
session.fireAllRules();
} finally {
session.dispose();
}
return sessionDescriptor.getScoreInliner();
}
@Override
public Constraint[] getConstraints() {
return kieBaseDescriptor.getConstraintToGlobalMap()
.keySet()
.toArray(Constraint[]::new);
}
public boolean isDroolsAlphaNetworkCompilationEnabled() {
return droolsAlphaNetworkCompilationEnabled;
}
private static final class ConstraintDisablingAgendaFilter implements AgendaFilter {
private final Set<String> disabledConstraintIdSet;
private final Map<Rule, Boolean> ruleEnabledCache = new HashMap<>();
public ConstraintDisablingAgendaFilter(Set<String> disabledConstraintIdSet) {
this.disabledConstraintIdSet = Objects.requireNonNull(disabledConstraintIdSet);
}
@Override
public boolean accept(Match match) {
Rule rule = match.getRule();
return ruleEnabledCache.computeIfAbsent(rule, r -> {
String constraintId = ConstraintMatchTotal.composeConstraintId(r.getPackageName(), r.getName());
return !disabledConstraintIdSet.contains(constraintId);
});
}
}
}
|
KieBaseConfiguration kieBaseConfiguration = KieServices.get().newKieBaseConfiguration();
kieBaseConfiguration.setOption(KieBaseMutabilityOption.DISABLED); // For performance; applicable to DRL too.
kieBaseConfiguration.setProperty(PropertySpecificOption.PROPERTY_NAME,
PropertySpecificOption.DISABLED.name()); // Users of CS must not rely on underlying Drools gimmicks.
KieBase kieBase = KieBaseBuilder.createKieBaseFromModel(model, kieBaseConfiguration);
if (droolsAlphaNetworkCompilationEnabled) {
KieBaseUpdaterANC.generateAndSetInMemoryANC(kieBase); // Enable Alpha Network Compiler for performance.
}
return kieBase;
| 1,765
| 193
| 1,958
|
<methods>public transient abstract AbstractScoreInliner<Score_> fireAndForget(java.lang.Object[]) ,public abstract org.optaplanner.core.api.score.stream.Constraint[] getConstraints() <variables>
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-drools/src/main/java/org/optaplanner/constraint/streams/drools/DroolsConstraintStreamScoreDirectorFactoryService.java
|
DroolsConstraintStreamScoreDirectorFactoryService
|
buildScoreDirectorFactory
|
class DroolsConstraintStreamScoreDirectorFactoryService<Solution_, Score_ extends Score<Score_>>
extends AbstractConstraintStreamScoreDirectorFactoryService<Solution_, Score_> {
@Override
public ScoreDirectorType getSupportedScoreDirectorType() {
return ScoreDirectorType.CONSTRAINT_STREAMS;
}
@Override
public Supplier<AbstractScoreDirectorFactory<Solution_, Score_>> buildScoreDirectorFactory(ClassLoader classLoader,
SolutionDescriptor<Solution_> solutionDescriptor, ScoreDirectorFactoryConfig config,
EnvironmentMode environmentMode) {<FILL_FUNCTION_BODY>}
@Override
public boolean supportsImplType(ConstraintStreamImplType constraintStreamImplType) {
return constraintStreamImplType == ConstraintStreamImplType.DROOLS;
}
@Override
public AbstractConstraintStreamScoreDirectorFactory<Solution_, Score_> buildScoreDirectorFactory(
SolutionDescriptor<Solution_> solutionDescriptor, ConstraintProvider constraintProvider,
EnvironmentMode environmentMode, boolean droolsAlphaNetworkCompilationEnabled) {
return new DroolsConstraintStreamScoreDirectorFactory<>(solutionDescriptor, constraintProvider,
droolsAlphaNetworkCompilationEnabled);
}
@Override
public ConstraintFactory buildConstraintFactory(SolutionDescriptor<Solution_> solutionDescriptor,
EnvironmentMode environmentMode) {
return new DroolsConstraintFactory<>(solutionDescriptor);
}
}
|
ConstraintStreamImplType constraintStreamImplType_ =
Objects.requireNonNullElse(config.getConstraintStreamImplType(), ConstraintStreamImplType.DROOLS);
if (constraintStreamImplType_ == BAVET) {
return null;
}
if (config.getConstraintProviderClass() != null) {
if (!ConstraintProvider.class.isAssignableFrom(config.getConstraintProviderClass())) {
throw new IllegalArgumentException(
"The constraintProviderClass (" + config.getConstraintProviderClass()
+ ") does not implement " + ConstraintProvider.class.getSimpleName() + ".");
}
return () -> {
ConstraintProvider constraintProvider = ConfigUtils.newInstance(config,
"constraintProviderClass", config.getConstraintProviderClass());
ConfigUtils.applyCustomProperties(constraintProvider, "constraintProviderClass",
config.getConstraintProviderCustomProperties(), "constraintProviderCustomProperties");
boolean isDroolsAlphaNetworkEnabled =
Objects.requireNonNullElse(config.isDroolsAlphaNetworkCompilationEnabled(), true);
if (config.getGizmoKieBaseSupplier() != null) {
return new DroolsConstraintStreamScoreDirectorFactory<>(solutionDescriptor,
(KieBaseDescriptor<Solution_>) config.getGizmoKieBaseSupplier(),
isDroolsAlphaNetworkEnabled);
}
return buildScoreDirectorFactory(solutionDescriptor, constraintProvider, environmentMode,
isDroolsAlphaNetworkEnabled);
};
} else {
if (config.getConstraintProviderCustomProperties() != null) {
throw new IllegalStateException("If there is no constraintProviderClass (" + config.getConstraintProviderClass()
+ "), then there can be no constraintProviderCustomProperties ("
+ config.getConstraintProviderCustomProperties() + ") either.");
}
return null;
}
| 367
| 463
| 830
|
<methods>public non-sealed void <init>() ,public abstract org.optaplanner.core.api.score.stream.ConstraintFactory buildConstraintFactory(SolutionDescriptor<Solution_>, org.optaplanner.core.config.solver.EnvironmentMode) ,public abstract AbstractConstraintStreamScoreDirectorFactory<Solution_,Score_> buildScoreDirectorFactory(SolutionDescriptor<Solution_>, org.optaplanner.core.api.score.stream.ConstraintProvider, org.optaplanner.core.config.solver.EnvironmentMode, boolean) ,public abstract boolean supportsImplType(org.optaplanner.core.api.score.stream.ConstraintStreamImplType) <variables>
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-drools/src/main/java/org/optaplanner/constraint/streams/drools/DroolsVariableFactory.java
|
DroolsVariableFactory
|
createVariable
|
class DroolsVariableFactory {
private final AtomicLong counter = new AtomicLong(0);
DroolsVariableFactory() {
// No external instances.
}
private String generateUniqueId(String baseName) {
return baseName + "_" + counter.incrementAndGet();
}
/**
* Declare a new {@link Variable} with a given name and no declared source.
* Delegates to {@link DSL#declarationOf(Class, String)}.
*
* @param clz type of the variable. Using {@link Object} will work in all cases, but Drools will spend unnecessary
* amount of time looking up applicable instances of that variable, as it has to traverse instances of all
* types in the working memory. Therefore, it is desirable to be as specific as possible.
* @param baseName name of the variable, mostly useful for debugging purposes. Will be decorated by a numeric
* identifier to prevent multiple variables of the same name to exist within left-hand side of a single rule.
* @param <U> generic type of the input variable
* @param <V> generic type of the output variable
* @return new variable declaration, not yet bound to anything
*/
public <U, V extends U> Variable<V> createVariable(Class<U> clz, String baseName) {
return (Variable<V>) declarationOf(clz, generateUniqueId(baseName));
}
/**
* Declares a new {@link Object}-typed variable, see {@link #createVariable(Class, String)} for details.
*/
public <U> Variable<U> createVariable(String baseName) {
return createVariable(Object.class, baseName);
}
/**
* Declare a new {@link Variable} with a given name, which will hold the result of applying a given mapping
* function on values of the provided variables.
*
* @param baseName name of the variable, mostly useful for debugging purposes. Will be decorated by a numeric
* identifier to prevent multiple variables of the same name to exist within left-hand side of a single rule.
* @param source1 never null; value of this is passed to the mapping function
* @param source2 never null; value of this is passed to the mapping function
* @param mapping never null
* @param <U> generic type of the first input variable
* @param <V> generic type of the second input variable
* @param <Result_> generic type of the new variable
* @return never null
*/
public <U, V, Result_> Variable<Result_> createVariable(String baseName, Variable<U> source1, Variable<V> source2,
BiFunction<U, V, Result_> mapping) {
return (Variable<Result_>) declarationOf(Object.class, generateUniqueId(baseName),
from(source1, source2, (value1, value2) -> {
Result_ result = mapping.apply(value1, value2);
if (result instanceof Iterable) { // Avoid flattening, which is a default from() behavior.
return Collections.singleton(result);
}
return result;
}));
}
/**
* As defined by {@link #createVariable(String, Variable, Variable, BiFunction)}.
*/
public <U, V, W, Result_> Variable<Result_> createVariable(String baseName, Variable<U> source1, Variable<V> source2,
Variable<W> source3, TriFunction<U, V, W, Result_> mapping) {
return (Variable<Result_>) declarationOf(Object.class, generateUniqueId(baseName),
from(source1, source2, source3, (value1, value2, value3) -> {
Result_ result = mapping.apply(value1, value2, value3);
if (result instanceof Iterable) { // Avoid flattening, which is a default from() behavior.
return Collections.singleton(result);
}
return result;
}));
}
/**
* As defined by {@link #createVariable(String, Variable, Variable, BiFunction)}.
*/
public <U, V, W, Y, Result_> Variable<Result_> createVariable(String baseName, Variable<U> source1, Variable<V> source2,
Variable<W> source3, Variable<Y> source4, QuadFunction<U, V, W, Y, Result_> mapping) {<FILL_FUNCTION_BODY>}
/**
* Declare a new {@link Variable} with a given name, which will hold the individual results of applying the given
* mapping function on the value of the provided variable.
* Each such result will trigger a single rule firing.
* (Default behavior of Drools' From node.)
*
* @param baseName name of the variable, mostly useful for debugging purposes. Will be decorated by a numeric
* identifier to prevent multiple variables of the same name to exist within left-hand side of a single rule.
* @param source never null; value of this is passed to the mapping function
* @param mapping never null
* @param <U> generic type of the input variable
* @param <Result_> generic type of the new variable
* @return
*/
public <U, Result_> Variable<Result_> createFlattenedVariable(String baseName, Variable<U> source,
Function<U, Iterable<Result_>> mapping) {
return (Variable<Result_>) declarationOf(Object.class, generateUniqueId(baseName),
from(source, mapping::apply)); // By default, from() flattens.
}
}
|
return (Variable<Result_>) declarationOf(Object.class, generateUniqueId(baseName),
from(source1, source2, source3, source4, (value1, value2, value3, value4) -> {
Result_ result = mapping.apply(value1, value2, value3, value4);
if (result instanceof Iterable) { // Avoid flattening, which is a default from() behavior.
return Collections.singleton(result);
}
return result;
}));
| 1,416
| 130
| 1,546
|
<no_super_class>
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-drools/src/main/java/org/optaplanner/constraint/streams/drools/OptaPlannerRuleEventListener.java
|
OptaPlannerRuleEventListener
|
undoPreviousMatch
|
class OptaPlannerRuleEventListener implements RuleEventListener {
@Override
public void onUpdateMatch(Match match) {
undoPreviousMatch((InternalMatch) match);
}
@Override
public void onDeleteMatch(Match match) {
undoPreviousMatch((InternalMatch) match);
}
public void undoPreviousMatch(InternalMatch match) {<FILL_FUNCTION_BODY>}
}
|
Runnable callback = match.getCallback();
/*
* Null callbacks can happen and are safe to ignore.
*
* If we insert a fact and then immediately delete it without firing any rules inbetween,
* a dummy match will be created by Drools and that match will not have our callback in it.
* Although this is inefficient, it was decided that the cure would have been worse than the disease.
*/
if (callback != null) {
callback.run();
match.setCallback(null);
}
| 106
| 134
| 240
|
<no_super_class>
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-drools/src/main/java/org/optaplanner/constraint/streams/drools/bi/DroolsFilterBiConstraintStream.java
|
DroolsFilterBiConstraintStream
|
toString
|
class DroolsFilterBiConstraintStream<Solution_, A, B>
extends DroolsAbstractBiConstraintStream<Solution_, A, B> {
private final DroolsAbstractBiConstraintStream<Solution_, A, B> parent;
private final Supplier<BiLeftHandSide<A, B>> leftHandSide;
public DroolsFilterBiConstraintStream(DroolsConstraintFactory<Solution_> constraintFactory,
DroolsAbstractBiConstraintStream<Solution_, A, B> parent, BiPredicate<A, B> biPredicate) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
this.leftHandSide = () -> parent.createLeftHandSide().andFilter(biPredicate);
}
@Override
public boolean guaranteesDistinct() {
return parent.guaranteesDistinct();
}
@Override
public BiLeftHandSide<A, B> createLeftHandSide() {
return leftHandSide.get();
}
@Override
public String toString() {<FILL_FUNCTION_BODY>}
}
|
return "BiFilter() with " + getChildStreams().size() + " children";
| 278
| 24
| 302
|
<methods>public void <init>(DroolsConstraintFactory<Solution_>, org.optaplanner.constraint.streams.common.RetrievalSemantics) ,public BiConstraintStream<A,B> filter(BiPredicate<A,B>) ,public BiConstraintStream<A,ResultB_> flattenLast(Function<B,Iterable<ResultB_>>) ,public UniConstraintStream<Result_> groupBy(BiConstraintCollector<A,B,ResultContainer_,Result_>) ,public BiConstraintStream<ResultA_,ResultB_> groupBy(BiConstraintCollector<A,B,ResultContainerA_,ResultA_>, BiConstraintCollector<A,B,ResultContainerB_,ResultB_>) ,public TriConstraintStream<ResultA_,ResultB_,ResultC_> groupBy(BiConstraintCollector<A,B,ResultContainerA_,ResultA_>, BiConstraintCollector<A,B,ResultContainerB_,ResultB_>, BiConstraintCollector<A,B,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_> groupBy(BiConstraintCollector<A,B,ResultContainerA_,ResultA_>, BiConstraintCollector<A,B,ResultContainerB_,ResultB_>, BiConstraintCollector<A,B,ResultContainerC_,ResultC_>, BiConstraintCollector<A,B,ResultContainerD_,ResultD_>) ,public UniConstraintStream<GroupKey_> groupBy(BiFunction<A,B,GroupKey_>) ,public BiConstraintStream<GroupKey_,Result_> groupBy(BiFunction<A,B,GroupKey_>, BiConstraintCollector<A,B,__,Result_>) ,public TriConstraintStream<GroupKey_,ResultB_,ResultC_> groupBy(BiFunction<A,B,GroupKey_>, BiConstraintCollector<A,B,ResultContainerB_,ResultB_>, BiConstraintCollector<A,B,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_> groupBy(BiFunction<A,B,GroupKey_>, BiConstraintCollector<A,B,ResultContainerB_,ResultB_>, BiConstraintCollector<A,B,ResultContainerC_,ResultC_>, BiConstraintCollector<A,B,ResultContainerD_,ResultD_>) ,public BiConstraintStream<GroupKeyA_,GroupKeyB_> groupBy(BiFunction<A,B,GroupKeyA_>, BiFunction<A,B,GroupKeyB_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_> groupBy(BiFunction<A,B,GroupKeyA_>, BiFunction<A,B,GroupKeyB_>, BiConstraintCollector<A,B,ResultContainer_,Result_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_> groupBy(BiFunction<A,B,GroupKeyA_>, BiFunction<A,B,GroupKeyB_>, BiConstraintCollector<A,B,ResultContainerC_,ResultC_>, BiConstraintCollector<A,B,ResultContainerD_,ResultD_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_> groupBy(BiFunction<A,B,GroupKeyA_>, BiFunction<A,B,GroupKeyB_>, BiFunction<A,B,GroupKeyC_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_> groupBy(BiFunction<A,B,GroupKeyA_>, BiFunction<A,B,GroupKeyB_>, BiFunction<A,B,GroupKeyC_>, BiConstraintCollector<A,B,ResultContainerD_,ResultD_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> groupBy(BiFunction<A,B,GroupKeyA_>, BiFunction<A,B,GroupKeyB_>, BiFunction<A,B,GroupKeyC_>, BiFunction<A,B,GroupKeyD_>) ,public final transient BiConstraintStream<A,B> ifExists(Class<C>, TriJoiner<A,B,C>[]) ,public final transient BiConstraintStream<A,B> ifExistsIncludingNullVars(Class<C>, TriJoiner<A,B,C>[]) ,public final transient BiConstraintStream<A,B> ifNotExists(Class<C>, TriJoiner<A,B,C>[]) ,public final transient BiConstraintStream<A,B> ifNotExistsIncludingNullVars(Class<C>, TriJoiner<A,B,C>[]) ,public BiConstraintBuilder<A,B,Score_> innerImpact(Score_, ToIntBiFunction<A,B>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public BiConstraintBuilder<A,B,Score_> innerImpact(Score_, ToLongBiFunction<A,B>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public BiConstraintBuilder<A,B,Score_> innerImpact(Score_, BiFunction<A,B,java.math.BigDecimal>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public final transient TriConstraintStream<A,B,C> join(UniConstraintStream<C>, TriJoiner<A,B,C>[]) ,public UniConstraintStream<ResultA_> map(BiFunction<A,B,ResultA_>) <variables>
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-drools/src/main/java/org/optaplanner/constraint/streams/drools/bi/DroolsGroupingBiConstraintStream.java
|
DroolsGroupingBiConstraintStream
|
toString
|
class DroolsGroupingBiConstraintStream<Solution_, NewA, NewB>
extends DroolsAbstractBiConstraintStream<Solution_, NewA, NewB> {
private final Supplier<BiLeftHandSide<NewA, NewB>> leftHandSide;
public <A> DroolsGroupingBiConstraintStream(DroolsConstraintFactory<Solution_> constraintFactory,
DroolsAbstractUniConstraintStream<Solution_, A> parent, Function<A, NewA> groupKeyAMapping,
Function<A, NewB> groupKeyBMapping) {
super(constraintFactory, parent.getRetrievalSemantics());
this.leftHandSide = () -> parent.createLeftHandSide().andGroupBy(groupKeyAMapping, groupKeyBMapping);
}
public <A, B> DroolsGroupingBiConstraintStream(DroolsConstraintFactory<Solution_> constraintFactory,
DroolsAbstractBiConstraintStream<Solution_, A, B> parent, BiFunction<A, B, NewA> groupKeyAMapping,
BiFunction<A, B, NewB> groupKeyBMapping) {
super(constraintFactory, parent.getRetrievalSemantics());
this.leftHandSide = () -> parent.createLeftHandSide().andGroupBy(groupKeyAMapping, groupKeyBMapping);
}
public <A, B, C> DroolsGroupingBiConstraintStream(DroolsConstraintFactory<Solution_> constraintFactory,
DroolsAbstractTriConstraintStream<Solution_, A, B, C> parent, TriFunction<A, B, C, NewA> groupKeyAMapping,
TriFunction<A, B, C, NewB> groupKeyBMapping) {
super(constraintFactory, parent.getRetrievalSemantics());
this.leftHandSide = () -> parent.createLeftHandSide().andGroupBy(groupKeyAMapping, groupKeyBMapping);
}
public <A, B, C, D> DroolsGroupingBiConstraintStream(DroolsConstraintFactory<Solution_> constraintFactory,
DroolsAbstractQuadConstraintStream<Solution_, A, B, C, D> parent,
QuadFunction<A, B, C, D, NewA> groupKeyAMapping, QuadFunction<A, B, C, D, NewB> groupKeyBMapping) {
super(constraintFactory, parent.getRetrievalSemantics());
this.leftHandSide = () -> parent.createLeftHandSide().andGroupBy(groupKeyAMapping, groupKeyBMapping);
}
public <A> DroolsGroupingBiConstraintStream(DroolsConstraintFactory<Solution_> constraintFactory,
DroolsAbstractUniConstraintStream<Solution_, A> parent, Function<A, NewA> groupKeyMapping,
UniConstraintCollector<A, ?, NewB> collector) {
super(constraintFactory, parent.getRetrievalSemantics());
this.leftHandSide = () -> parent.createLeftHandSide().andGroupBy(groupKeyMapping, collector);
}
public <A, B> DroolsGroupingBiConstraintStream(DroolsConstraintFactory<Solution_> constraintFactory,
DroolsAbstractBiConstraintStream<Solution_, A, B> parent, BiFunction<A, B, NewA> groupKeyMapping,
BiConstraintCollector<A, B, ?, NewB> collector) {
super(constraintFactory, parent.getRetrievalSemantics());
this.leftHandSide = () -> parent.createLeftHandSide().andGroupBy(groupKeyMapping, collector);
}
public <A, B, C> DroolsGroupingBiConstraintStream(DroolsConstraintFactory<Solution_> constraintFactory,
DroolsAbstractTriConstraintStream<Solution_, A, B, C> parent, TriFunction<A, B, C, NewA> groupKeyMapping,
TriConstraintCollector<A, B, C, ?, NewB> collector) {
super(constraintFactory, parent.getRetrievalSemantics());
this.leftHandSide = () -> parent.createLeftHandSide().andGroupBy(groupKeyMapping, collector);
}
public <A, B, C, D> DroolsGroupingBiConstraintStream(DroolsConstraintFactory<Solution_> constraintFactory,
DroolsAbstractQuadConstraintStream<Solution_, A, B, C, D> parent,
QuadFunction<A, B, C, D, NewA> groupKeyMapping, QuadConstraintCollector<A, B, C, D, ?, NewB> collector) {
super(constraintFactory, parent.getRetrievalSemantics());
this.leftHandSide = () -> parent.createLeftHandSide().andGroupBy(groupKeyMapping, collector);
}
public <A> DroolsGroupingBiConstraintStream(DroolsConstraintFactory<Solution_> constraintFactory,
DroolsAbstractUniConstraintStream<Solution_, A> parent, UniConstraintCollector<A, ?, NewA> collectorA,
UniConstraintCollector<A, ?, NewB> collectorB) {
super(constraintFactory, parent.getRetrievalSemantics());
this.leftHandSide = () -> parent.createLeftHandSide().andGroupBy(collectorA, collectorB);
}
public <A, B> DroolsGroupingBiConstraintStream(DroolsConstraintFactory<Solution_> constraintFactory,
DroolsAbstractBiConstraintStream<Solution_, A, B> parent, BiConstraintCollector<A, B, ?, NewA> collectorA,
BiConstraintCollector<A, B, ?, NewB> collectorB) {
super(constraintFactory, parent.getRetrievalSemantics());
this.leftHandSide = () -> parent.createLeftHandSide().andGroupBy(collectorA, collectorB);
}
public <A, B, C> DroolsGroupingBiConstraintStream(DroolsConstraintFactory<Solution_> constraintFactory,
DroolsAbstractTriConstraintStream<Solution_, A, B, C> parent,
TriConstraintCollector<A, B, C, ?, NewA> collectorA, TriConstraintCollector<A, B, C, ?, NewB> collectorB) {
super(constraintFactory, parent.getRetrievalSemantics());
this.leftHandSide = () -> parent.createLeftHandSide().andGroupBy(collectorA, collectorB);
}
public <A, B, C, D> DroolsGroupingBiConstraintStream(DroolsConstraintFactory<Solution_> constraintFactory,
DroolsAbstractQuadConstraintStream<Solution_, A, B, C, D> parent,
QuadConstraintCollector<A, B, C, D, ?, NewA> collectorA,
QuadConstraintCollector<A, B, C, D, ?, NewB> collectorB) {
super(constraintFactory, parent.getRetrievalSemantics());
this.leftHandSide = () -> parent.createLeftHandSide().andGroupBy(collectorA, collectorB);
}
@Override
public boolean guaranteesDistinct() {
return true;
}
@Override
public BiLeftHandSide<NewA, NewB> createLeftHandSide() {
return leftHandSide.get();
}
@Override
public String toString() {<FILL_FUNCTION_BODY>}
}
|
return "BiGroup() with " + getChildStreams().size() + " children";
| 1,808
| 24
| 1,832
|
<methods>public void <init>(DroolsConstraintFactory<Solution_>, org.optaplanner.constraint.streams.common.RetrievalSemantics) ,public BiConstraintStream<NewA,NewB> filter(BiPredicate<NewA,NewB>) ,public BiConstraintStream<NewA,ResultB_> flattenLast(Function<NewB,Iterable<ResultB_>>) ,public UniConstraintStream<Result_> groupBy(BiConstraintCollector<NewA,NewB,ResultContainer_,Result_>) ,public BiConstraintStream<ResultA_,ResultB_> groupBy(BiConstraintCollector<NewA,NewB,ResultContainerA_,ResultA_>, BiConstraintCollector<NewA,NewB,ResultContainerB_,ResultB_>) ,public TriConstraintStream<ResultA_,ResultB_,ResultC_> groupBy(BiConstraintCollector<NewA,NewB,ResultContainerA_,ResultA_>, BiConstraintCollector<NewA,NewB,ResultContainerB_,ResultB_>, BiConstraintCollector<NewA,NewB,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_> groupBy(BiConstraintCollector<NewA,NewB,ResultContainerA_,ResultA_>, BiConstraintCollector<NewA,NewB,ResultContainerB_,ResultB_>, BiConstraintCollector<NewA,NewB,ResultContainerC_,ResultC_>, BiConstraintCollector<NewA,NewB,ResultContainerD_,ResultD_>) ,public UniConstraintStream<GroupKey_> groupBy(BiFunction<NewA,NewB,GroupKey_>) ,public BiConstraintStream<GroupKey_,Result_> groupBy(BiFunction<NewA,NewB,GroupKey_>, BiConstraintCollector<NewA,NewB,__,Result_>) ,public TriConstraintStream<GroupKey_,ResultB_,ResultC_> groupBy(BiFunction<NewA,NewB,GroupKey_>, BiConstraintCollector<NewA,NewB,ResultContainerB_,ResultB_>, BiConstraintCollector<NewA,NewB,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_> groupBy(BiFunction<NewA,NewB,GroupKey_>, BiConstraintCollector<NewA,NewB,ResultContainerB_,ResultB_>, BiConstraintCollector<NewA,NewB,ResultContainerC_,ResultC_>, BiConstraintCollector<NewA,NewB,ResultContainerD_,ResultD_>) ,public BiConstraintStream<GroupKeyA_,GroupKeyB_> groupBy(BiFunction<NewA,NewB,GroupKeyA_>, BiFunction<NewA,NewB,GroupKeyB_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_> groupBy(BiFunction<NewA,NewB,GroupKeyA_>, BiFunction<NewA,NewB,GroupKeyB_>, BiConstraintCollector<NewA,NewB,ResultContainer_,Result_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_> groupBy(BiFunction<NewA,NewB,GroupKeyA_>, BiFunction<NewA,NewB,GroupKeyB_>, BiConstraintCollector<NewA,NewB,ResultContainerC_,ResultC_>, BiConstraintCollector<NewA,NewB,ResultContainerD_,ResultD_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_> groupBy(BiFunction<NewA,NewB,GroupKeyA_>, BiFunction<NewA,NewB,GroupKeyB_>, BiFunction<NewA,NewB,GroupKeyC_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_> groupBy(BiFunction<NewA,NewB,GroupKeyA_>, BiFunction<NewA,NewB,GroupKeyB_>, BiFunction<NewA,NewB,GroupKeyC_>, BiConstraintCollector<NewA,NewB,ResultContainerD_,ResultD_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> groupBy(BiFunction<NewA,NewB,GroupKeyA_>, BiFunction<NewA,NewB,GroupKeyB_>, BiFunction<NewA,NewB,GroupKeyC_>, BiFunction<NewA,NewB,GroupKeyD_>) ,public final transient BiConstraintStream<NewA,NewB> ifExists(Class<C>, TriJoiner<NewA,NewB,C>[]) ,public final transient BiConstraintStream<NewA,NewB> ifExistsIncludingNullVars(Class<C>, TriJoiner<NewA,NewB,C>[]) ,public final transient BiConstraintStream<NewA,NewB> ifNotExists(Class<C>, TriJoiner<NewA,NewB,C>[]) ,public final transient BiConstraintStream<NewA,NewB> ifNotExistsIncludingNullVars(Class<C>, TriJoiner<NewA,NewB,C>[]) ,public BiConstraintBuilder<NewA,NewB,Score_> innerImpact(Score_, ToIntBiFunction<NewA,NewB>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public BiConstraintBuilder<NewA,NewB,Score_> innerImpact(Score_, ToLongBiFunction<NewA,NewB>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public BiConstraintBuilder<NewA,NewB,Score_> innerImpact(Score_, BiFunction<NewA,NewB,java.math.BigDecimal>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public final transient TriConstraintStream<NewA,NewB,C> join(UniConstraintStream<C>, TriJoiner<NewA,NewB,C>[]) ,public UniConstraintStream<ResultA_> map(BiFunction<NewA,NewB,ResultA_>) <variables>
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-drools/src/main/java/org/optaplanner/constraint/streams/drools/bi/DroolsJoinBiConstraintStream.java
|
DroolsJoinBiConstraintStream
|
toString
|
class DroolsJoinBiConstraintStream<Solution_, A, B>
extends DroolsAbstractBiConstraintStream<Solution_, A, B> {
private final Supplier<BiLeftHandSide<A, B>> leftHandSide;
private final boolean guaranteesDistinct;
public DroolsJoinBiConstraintStream(DroolsConstraintFactory<Solution_> constraintFactory,
DroolsAbstractUniConstraintStream<Solution_, A> parent,
DroolsAbstractUniConstraintStream<Solution_, B> otherStream, BiJoiner<A, B> biJoiner) {
super(constraintFactory, parent.getRetrievalSemantics());
this.leftHandSide = () -> parent.createLeftHandSide().andJoin(otherStream.createLeftHandSide(), biJoiner);
this.guaranteesDistinct = parent.guaranteesDistinct() && otherStream.guaranteesDistinct();
}
@Override
public boolean guaranteesDistinct() {
return guaranteesDistinct;
}
@Override
public BiLeftHandSide<A, B> createLeftHandSide() {
return leftHandSide.get();
}
@Override
public String toString() {<FILL_FUNCTION_BODY>}
}
|
return "BiJoin() with " + getChildStreams().size() + " children";
| 308
| 24
| 332
|
<methods>public void <init>(DroolsConstraintFactory<Solution_>, org.optaplanner.constraint.streams.common.RetrievalSemantics) ,public BiConstraintStream<A,B> filter(BiPredicate<A,B>) ,public BiConstraintStream<A,ResultB_> flattenLast(Function<B,Iterable<ResultB_>>) ,public UniConstraintStream<Result_> groupBy(BiConstraintCollector<A,B,ResultContainer_,Result_>) ,public BiConstraintStream<ResultA_,ResultB_> groupBy(BiConstraintCollector<A,B,ResultContainerA_,ResultA_>, BiConstraintCollector<A,B,ResultContainerB_,ResultB_>) ,public TriConstraintStream<ResultA_,ResultB_,ResultC_> groupBy(BiConstraintCollector<A,B,ResultContainerA_,ResultA_>, BiConstraintCollector<A,B,ResultContainerB_,ResultB_>, BiConstraintCollector<A,B,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<ResultA_,ResultB_,ResultC_,ResultD_> groupBy(BiConstraintCollector<A,B,ResultContainerA_,ResultA_>, BiConstraintCollector<A,B,ResultContainerB_,ResultB_>, BiConstraintCollector<A,B,ResultContainerC_,ResultC_>, BiConstraintCollector<A,B,ResultContainerD_,ResultD_>) ,public UniConstraintStream<GroupKey_> groupBy(BiFunction<A,B,GroupKey_>) ,public BiConstraintStream<GroupKey_,Result_> groupBy(BiFunction<A,B,GroupKey_>, BiConstraintCollector<A,B,__,Result_>) ,public TriConstraintStream<GroupKey_,ResultB_,ResultC_> groupBy(BiFunction<A,B,GroupKey_>, BiConstraintCollector<A,B,ResultContainerB_,ResultB_>, BiConstraintCollector<A,B,ResultContainerC_,ResultC_>) ,public QuadConstraintStream<GroupKey_,ResultB_,ResultC_,ResultD_> groupBy(BiFunction<A,B,GroupKey_>, BiConstraintCollector<A,B,ResultContainerB_,ResultB_>, BiConstraintCollector<A,B,ResultContainerC_,ResultC_>, BiConstraintCollector<A,B,ResultContainerD_,ResultD_>) ,public BiConstraintStream<GroupKeyA_,GroupKeyB_> groupBy(BiFunction<A,B,GroupKeyA_>, BiFunction<A,B,GroupKeyB_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,Result_> groupBy(BiFunction<A,B,GroupKeyA_>, BiFunction<A,B,GroupKeyB_>, BiConstraintCollector<A,B,ResultContainer_,Result_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,ResultC_,ResultD_> groupBy(BiFunction<A,B,GroupKeyA_>, BiFunction<A,B,GroupKeyB_>, BiConstraintCollector<A,B,ResultContainerC_,ResultC_>, BiConstraintCollector<A,B,ResultContainerD_,ResultD_>) ,public TriConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_> groupBy(BiFunction<A,B,GroupKeyA_>, BiFunction<A,B,GroupKeyB_>, BiFunction<A,B,GroupKeyC_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,ResultD_> groupBy(BiFunction<A,B,GroupKeyA_>, BiFunction<A,B,GroupKeyB_>, BiFunction<A,B,GroupKeyC_>, BiConstraintCollector<A,B,ResultContainerD_,ResultD_>) ,public QuadConstraintStream<GroupKeyA_,GroupKeyB_,GroupKeyC_,GroupKeyD_> groupBy(BiFunction<A,B,GroupKeyA_>, BiFunction<A,B,GroupKeyB_>, BiFunction<A,B,GroupKeyC_>, BiFunction<A,B,GroupKeyD_>) ,public final transient BiConstraintStream<A,B> ifExists(Class<C>, TriJoiner<A,B,C>[]) ,public final transient BiConstraintStream<A,B> ifExistsIncludingNullVars(Class<C>, TriJoiner<A,B,C>[]) ,public final transient BiConstraintStream<A,B> ifNotExists(Class<C>, TriJoiner<A,B,C>[]) ,public final transient BiConstraintStream<A,B> ifNotExistsIncludingNullVars(Class<C>, TriJoiner<A,B,C>[]) ,public BiConstraintBuilder<A,B,Score_> innerImpact(Score_, ToIntBiFunction<A,B>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public BiConstraintBuilder<A,B,Score_> innerImpact(Score_, ToLongBiFunction<A,B>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public BiConstraintBuilder<A,B,Score_> innerImpact(Score_, BiFunction<A,B,java.math.BigDecimal>, org.optaplanner.constraint.streams.common.ScoreImpactType) ,public final transient TriConstraintStream<A,B,C> join(UniConstraintStream<C>, TriJoiner<A,B,C>[]) ,public UniConstraintStream<ResultA_> map(BiFunction<A,B,ResultA_>) <variables>
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-drools/src/main/java/org/optaplanner/constraint/streams/drools/common/AbstractAccumulator.java
|
AbstractAccumulator
|
accumulate
|
class AbstractAccumulator<ResultContainer_, Result_> implements Accumulator {
private final Supplier<ResultContainer_> containerSupplier;
private final Function<ResultContainer_, Result_> finisher;
private volatile boolean initialized = false;
protected AbstractAccumulator(Supplier<ResultContainer_> containerSupplier,
Function<ResultContainer_, Result_> finisher) {
this.containerSupplier = Objects.requireNonNull(containerSupplier);
this.finisher = Objects.requireNonNull(finisher);
}
protected static <X> Function<BaseTuple, X> getValueExtractor(Declaration declaration, BaseTuple leftTuple) {
return new ValueExtractor<>(declaration, leftTuple);
}
@Override
public final Object createWorkingMemoryContext() {
return null;
}
@Override
public final Object createContext() {
return null; // We always create and init during init(...).
}
@Override
public final ResultContainer_ init(Object workingMemoryContext, Object context, BaseTuple leftTuple,
Declaration[] declarations, ValueResolver reteEvaluator) {
return containerSupplier.get();
}
@Override
public final Object accumulate(Object workingMemoryContext, Object context, BaseTuple leftTuple,
FactHandle handle, Declaration[] declarations, Declaration[] innerDeclarations,
ValueResolver reteEvaluator) {<FILL_FUNCTION_BODY>}
protected abstract Runnable accumulate(ResultContainer_ context, BaseTuple leftTuple, FactHandle handle,
Declaration[] innerDeclarations);
protected abstract void initialize(BaseTuple leftTuple, Declaration[] innerDeclarations);
@Override
public final boolean supportsReverse() {
return true;
}
@Override
public final boolean tryReverse(Object workingMemoryContext, Object context, BaseTuple leftTuple,
FactHandle handle, Object value, Declaration[] declarations, Declaration[] innerDeclarations,
ValueResolver reteEvaluator) {
((Runnable) value).run();
return true;
}
@Override
public final Result_ getResult(Object workingMemoryContext, Object context, BaseTuple leftTuple,
Declaration[] declarations, ValueResolver reteEvaluator) {
return finisher.apply((ResultContainer_) context);
}
}
|
/*
* Accumulator instances are created within the KieBase, not within the KieSession.
* This means that multiple sessions from the same KieBase may be calling this method
* on a shared accumulator from different threads.
* (Multi-threaded solving, moveThreadCount > 1.)
*
* The logical place for this call would be the init(...) method of the Accumulator interface.
* Unfortunately, we need access to innerDeclarations to be able to perform the accumulation quickly,
* and it only becomes available when this accumulate(...) method is called.
* Therefore, initialization of our accumulator can only happen when the accumulate(...) method is called,
* and therefore the initialization needs to be properly synchronized.
*/
if (!initialized) {
synchronized (this) {
if (!initialized) {
initialize(leftTuple, innerDeclarations);
initialized = true;
}
}
}
return accumulate((ResultContainer_) context, leftTuple, handle, innerDeclarations);
| 606
| 256
| 862
|
<no_super_class>
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-drools/src/main/java/org/optaplanner/constraint/streams/drools/common/AbstractRuleContext.java
|
AbstractRuleContext
|
createExceptionOnImpact
|
class AbstractRuleContext {
private final List<ViewItem<?>> viewItems;
protected AbstractRuleContext(ViewItem<?>... viewItems) {
this.viewItems = Arrays.stream(viewItems).collect(Collectors.toList());
}
protected static void runConsequence(DroolsConstraint<?> constraint, Drools drools,
WeightedScoreImpacter<?, ?> scoreImpacter, int impact, JustificationsSupplier justificationsSupplier) {
try {
constraint.assertCorrectImpact(impact);
UndoScoreImpacter undoImpact = scoreImpacter.impactScore(impact, justificationsSupplier);
addUndo(drools, undoImpact);
} catch (Exception e) {
throw createExceptionOnImpact(constraint, e);
}
}
private static void addUndo(Drools drools, UndoScoreImpacter undoImpact) {
InternalMatch match = (InternalMatch) ((RuleContext) drools).getMatch();
match.setCallback(undoImpact);
}
private static RuntimeException createExceptionOnImpact(DroolsConstraint<?> constraint, Exception cause) {<FILL_FUNCTION_BODY>}
protected static void runConsequence(DroolsConstraint<?> constraint, Drools drools,
WeightedScoreImpacter<?, ?> scoreImpacter, long impact, JustificationsSupplier justificationsSupplier) {
try {
constraint.assertCorrectImpact(impact);
UndoScoreImpacter undoImpact = scoreImpacter.impactScore(impact, justificationsSupplier);
addUndo(drools, undoImpact);
} catch (Exception e) {
throw createExceptionOnImpact(constraint, e);
}
}
protected static void runConsequence(DroolsConstraint<?> constraint, Drools drools,
WeightedScoreImpacter<?, ?> scoreImpacter, BigDecimal impact, JustificationsSupplier justificationsSupplier) {
try {
constraint.assertCorrectImpact(impact);
UndoScoreImpacter undoImpact = scoreImpacter.impactScore(impact, justificationsSupplier);
addUndo(drools, undoImpact);
} catch (Exception e) {
throw createExceptionOnImpact(constraint, e);
}
}
protected <Solution_> RuleBuilder<Solution_> assemble(ConsequenceBuilder<Solution_> consequenceBuilder) {
return (constraint, scoreImpacterGlobal) -> {
List<RuleItemBuilder<?>> ruleItemBuilderList = new ArrayList<>(viewItems);
ruleItemBuilderList.add(consequenceBuilder.apply(constraint, scoreImpacterGlobal));
return rule(constraint.getConstraintPackage(), constraint.getConstraintName())
.build(ruleItemBuilderList.toArray(new RuleItemBuilder[0]));
};
}
}
|
return new IllegalStateException(
"Consequence of a constraint (" + constraint.getConstraintId() + ") threw an exception.", cause);
| 759
| 35
| 794
|
<no_super_class>
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-drools/src/main/java/org/optaplanner/constraint/streams/drools/common/BiRuleContext.java
|
BiRuleContext
|
newRuleBuilder
|
class BiRuleContext<A, B> extends AbstractRuleContext {
private final Variable<A> variableA;
private final Variable<B> variableB;
public BiRuleContext(Variable<A> variableA, Variable<B> variableB, ViewItem<?>... viewItems) {
super(viewItems);
this.variableA = Objects.requireNonNull(variableA);
this.variableB = Objects.requireNonNull(variableB);
}
public <Solution_> RuleBuilder<Solution_> newRuleBuilder(ToIntBiFunction<A, B> matchWeigher) {
ConsequenceBuilder<Solution_> consequenceBuilder =
(constraint, scoreImpacterGlobal) -> DSL.on(scoreImpacterGlobal, variableA, variableB)
.execute((drools, scoreImpacter, a, b) -> {
JustificationsSupplier justificationsSupplier =
scoreImpacter.getContext().isConstraintMatchEnabled()
? of(constraint, constraint.getJustificationMapping(),
constraint.getIndictedObjectsMapping(), a, b)
: null;
runConsequence(constraint, drools, scoreImpacter, matchWeigher.applyAsInt(a, b),
justificationsSupplier);
});
return assemble(consequenceBuilder);
}
public <Solution_> RuleBuilder<Solution_> newRuleBuilder(ToLongBiFunction<A, B> matchWeigher) {
ConsequenceBuilder<Solution_> consequenceBuilder =
(constraint, scoreImpacterGlobal) -> DSL.on(scoreImpacterGlobal, variableA, variableB)
.execute((drools, scoreImpacter, a, b) -> {
JustificationsSupplier justificationsSupplier =
scoreImpacter.getContext().isConstraintMatchEnabled()
? of(constraint, constraint.getJustificationMapping(),
constraint.getIndictedObjectsMapping(), a, b)
: null;
runConsequence(constraint, drools, scoreImpacter, matchWeigher.applyAsLong(a, b),
justificationsSupplier);
});
return assemble(consequenceBuilder);
}
public <Solution_> RuleBuilder<Solution_> newRuleBuilder(BiFunction<A, B, BigDecimal> matchWeigher) {<FILL_FUNCTION_BODY>}
}
|
ConsequenceBuilder<Solution_> consequenceBuilder =
(constraint, scoreImpacterGlobal) -> DSL.on(scoreImpacterGlobal, variableA, variableB)
.execute((drools, scoreImpacter, a, b) -> {
JustificationsSupplier justificationsSupplier =
scoreImpacter.getContext().isConstraintMatchEnabled()
? of(constraint, constraint.getJustificationMapping(),
constraint.getIndictedObjectsMapping(), a, b)
: null;
runConsequence(constraint, drools, scoreImpacter, matchWeigher.apply(a, b),
justificationsSupplier);
});
return assemble(consequenceBuilder);
| 591
| 174
| 765
|
<methods><variables>private final non-sealed List<ViewItem<?>> viewItems
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-drools/src/main/java/org/optaplanner/constraint/streams/drools/common/BiTuple.java
|
BiTuple
|
toString
|
class BiTuple<A, B> implements FactTuple {
public final A a;
public final B b;
private final int hashCode;
public BiTuple(A a, B b) {
this.a = a;
this.b = b;
this.hashCode = Objects.hash(a, b);
}
@Override
public List<Object> asList() {
return Arrays.asList(a, b);
}
@Override
public boolean equals(final Object o) {
if (this == o) {
return true;
}
if (o == null || !Objects.equals(getClass(), o.getClass())) {
return false;
}
final BiTuple<?, ?> other = (BiTuple<?, ?>) o;
return hashCode == other.hashCode &&
Objects.equals(a, other.a) &&
Objects.equals(b, other.b);
}
@Override
public int hashCode() {
return hashCode;
}
@Override
public String toString() {<FILL_FUNCTION_BODY>}
}
|
return "BiTuple(" + a + ", " + b + ")";
| 295
| 21
| 316
|
<no_super_class>
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-drools/src/main/java/org/optaplanner/constraint/streams/drools/common/DirectPatternVariable.java
|
DirectPatternVariable
|
extract
|
class DirectPatternVariable<A> extends AbstractPatternVariable<A, A, DirectPatternVariable<A>> {
DirectPatternVariable(Variable<A> aVariable) {
this(aVariable, Collections.emptyList());
}
DirectPatternVariable(Variable<A> aVariable, List<ViewItem<?>> prerequisiteExpressions) {
super(aVariable, pattern(aVariable), prerequisiteExpressions, Collections.emptyList());
}
DirectPatternVariable(Variable<A> aVariable, ViewItem<?> prerequisiteExpression) {
this(aVariable, Collections.singletonList(prerequisiteExpression));
}
private DirectPatternVariable(DirectPatternVariable<A> patternCreator, ViewItem<?> dependentExpression) {
super(patternCreator, dependentExpression);
}
@Override
protected A extract(A a) {<FILL_FUNCTION_BODY>}
@Override
public DirectPatternVariable<A> addDependentExpression(ViewItem<?> expression) {
return new DirectPatternVariable<>(this, expression);
}
}
|
return a; // Values of direct variables come straight from the pattern.
| 277
| 20
| 297
|
<methods>public final DirectPatternVariable<A> bind(Variable<BoundVar_>, Function<A,BoundVar_>) ,public final DirectPatternVariable<A> bind(Variable<BoundVar_>, Variable<LeftJoinVar_>, BiFunction<A,LeftJoinVar_,BoundVar_>) ,public final DirectPatternVariable<A> bind(Variable<BoundVar_>, Variable<LeftJoinVarA_>, Variable<LeftJoinVarB_>, TriFunction<A,LeftJoinVarA_,LeftJoinVarB_,BoundVar_>) ,public final DirectPatternVariable<A> bind(Variable<BoundVar_>, Variable<LeftJoinVarA_>, Variable<LeftJoinVarB_>, Variable<LeftJoinVarC_>, QuadFunction<A,LeftJoinVarA_,LeftJoinVarB_,LeftJoinVarC_,BoundVar_>) ,public final List<ViewItem<?>> build() ,public final DirectPatternVariable<A> filter(Predicate<A>) ,public final DirectPatternVariable<A> filter(BiPredicate<LeftJoinVar_,A>, Variable<LeftJoinVar_>) ,public final DirectPatternVariable<A> filter(TriPredicate<LeftJoinVarA_,LeftJoinVarB_,A>, Variable<LeftJoinVarA_>, Variable<LeftJoinVarB_>) ,public final DirectPatternVariable<A> filter(QuadPredicate<LeftJoinVarA_,LeftJoinVarB_,LeftJoinVarC_,A>, Variable<LeftJoinVarA_>, Variable<LeftJoinVarB_>, Variable<LeftJoinVarC_>) ,public final DirectPatternVariable<A> filterForJoin(Variable<LeftJoinVar_>, DefaultBiJoiner<LeftJoinVar_,A>, org.optaplanner.core.impl.score.stream.JoinerType, int) ,public final DirectPatternVariable<A> filterForJoin(Variable<LeftJoinVarA_>, Variable<LeftJoinVarB_>, DefaultTriJoiner<LeftJoinVarA_,LeftJoinVarB_,A>, org.optaplanner.core.impl.score.stream.JoinerType, int) ,public final DirectPatternVariable<A> filterForJoin(Variable<LeftJoinVarA_>, Variable<LeftJoinVarB_>, Variable<LeftJoinVarC_>, DefaultQuadJoiner<LeftJoinVarA_,LeftJoinVarB_,LeftJoinVarC_,A>, org.optaplanner.core.impl.score.stream.JoinerType, int) ,public List<ViewItem<?>> getDependentExpressions() ,public List<ViewItem<?>> getPrerequisiteExpressions() ,public Variable<A> getPrimaryVariable() <variables>private final non-sealed List<ViewItem<?>> dependentExpressions,private final non-sealed List<ViewItem<?>> prerequisiteExpressions,private final non-sealed Variable<A> primaryVariable
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-drools/src/main/java/org/optaplanner/constraint/streams/drools/common/QuadAccumulator.java
|
QuadAccumulator
|
initialize
|
class QuadAccumulator<A, B, C, D, ResultContainer_, Result_>
extends AbstractAccumulator<ResultContainer_, Result_> {
private final String varA;
private final String varB;
private final String varC;
private final String varD;
private final PentaFunction<ResultContainer_, A, B, C, D, Runnable> accumulator;
private Function<BaseTuple, A> valueExtractorA;
private Function<BaseTuple, B> valueExtractorB;
private Function<BaseTuple, C> valueExtractorC;
private Function<BaseTuple, D> valueExtractorD;
public QuadAccumulator(Variable<A> varA, Variable<B> varB, Variable<C> varC, Variable<D> varD,
QuadConstraintCollector<A, B, C, D, ResultContainer_, Result_> collector) {
super(collector.supplier(), collector.finisher());
this.accumulator = Objects.requireNonNull(collector.accumulator());
this.varA = varA.getName();
this.varB = varB.getName();
this.varC = varC.getName();
this.varD = varD.getName();
}
@Override
protected Runnable accumulate(ResultContainer_ context, BaseTuple leftTuple, FactHandle handle,
Declaration[] innerDeclarations) {
A a = valueExtractorA.apply(leftTuple);
B b = valueExtractorB.apply(leftTuple);
C c = valueExtractorC.apply(leftTuple);
D d = valueExtractorD.apply(leftTuple);
return accumulator.apply(context, a, b, c, d);
}
@Override
protected void initialize(BaseTuple leftTuple, Declaration[] innerDeclarations) {<FILL_FUNCTION_BODY>}
}
|
for (Declaration declaration : innerDeclarations) {
if (declaration.getBindingName().equals(varA)) {
valueExtractorA = getValueExtractor(declaration, leftTuple);
} else if (declaration.getBindingName().equals(varB)) {
valueExtractorB = getValueExtractor(declaration, leftTuple);
} else if (declaration.getBindingName().equals(varC)) {
valueExtractorC = getValueExtractor(declaration, leftTuple);
} else if (declaration.getBindingName().equals(varD)) {
valueExtractorD = getValueExtractor(declaration, leftTuple);
}
}
| 484
| 172
| 656
|
<methods>public final java.lang.Object accumulate(java.lang.Object, java.lang.Object, BaseTuple, FactHandle, Declaration[], Declaration[], ValueResolver) ,public final java.lang.Object createContext() ,public final java.lang.Object createWorkingMemoryContext() ,public final Result_ getResult(java.lang.Object, java.lang.Object, BaseTuple, Declaration[], ValueResolver) ,public final ResultContainer_ init(java.lang.Object, java.lang.Object, BaseTuple, Declaration[], ValueResolver) ,public final boolean supportsReverse() ,public final boolean tryReverse(java.lang.Object, java.lang.Object, BaseTuple, FactHandle, java.lang.Object, Declaration[], Declaration[], ValueResolver) <variables>private final non-sealed Supplier<ResultContainer_> containerSupplier,private final non-sealed Function<ResultContainer_,Result_> finisher,private volatile boolean initialized
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-drools/src/main/java/org/optaplanner/constraint/streams/drools/common/QuadTuple.java
|
QuadTuple
|
toString
|
class QuadTuple<A, B, C, D> implements FactTuple {
public final A a;
public final B b;
public final C c;
public final D d;
private final int hashCode;
public QuadTuple(A a, B b, C c, D d) {
this.a = a;
this.b = b;
this.c = c;
this.d = d;
this.hashCode = Objects.hash(a, b, c, d);
}
@Override
public List<Object> asList() {
return Arrays.asList(a, b, c, d);
}
@Override
public boolean equals(final Object o) {
if (this == o) {
return true;
}
if (o == null || !Objects.equals(getClass(), o.getClass())) {
return false;
}
final QuadTuple<?, ?, ?, ?> other = (QuadTuple<?, ?, ?, ?>) o;
return hashCode == other.hashCode &&
Objects.equals(a, other.a) &&
Objects.equals(b, other.b) &&
Objects.equals(c, other.c) &&
Objects.equals(d, other.d);
}
@Override
public int hashCode() {
return hashCode;
}
@Override
public String toString() {<FILL_FUNCTION_BODY>}
}
|
return "QuadTuple(" + a + ", " + b + ", " + c + ", " + d + ")";
| 383
| 32
| 415
|
<no_super_class>
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-drools/src/main/java/org/optaplanner/constraint/streams/drools/common/TriAccumulator.java
|
TriAccumulator
|
initialize
|
class TriAccumulator<A, B, C, ResultContainer_, Result_> extends AbstractAccumulator<ResultContainer_, Result_> {
private final String varA;
private final String varB;
private final String varC;
private final QuadFunction<ResultContainer_, A, B, C, Runnable> accumulator;
private Function<BaseTuple, A> valueExtractorA;
private Function<BaseTuple, B> valueExtractorB;
private Function<BaseTuple, C> valueExtractorC;
public TriAccumulator(Variable<A> varA, Variable<B> varB, Variable<C> varC,
TriConstraintCollector<A, B, C, ResultContainer_, Result_> collector) {
super(collector.supplier(), collector.finisher());
this.accumulator = Objects.requireNonNull(collector.accumulator());
this.varA = varA.getName();
this.varB = varB.getName();
this.varC = varC.getName();
}
@Override
protected Runnable accumulate(ResultContainer_ context, BaseTuple leftTuple, FactHandle handle,
Declaration[] innerDeclarations) {
A a = valueExtractorA.apply(leftTuple);
B b = valueExtractorB.apply(leftTuple);
C c = valueExtractorC.apply(leftTuple);
return accumulator.apply(context, a, b, c);
}
@Override
protected void initialize(BaseTuple leftTuple, Declaration[] innerDeclarations) {<FILL_FUNCTION_BODY>}
}
|
for (Declaration declaration : innerDeclarations) {
if (declaration.getBindingName().equals(varA)) {
valueExtractorA = getValueExtractor(declaration, leftTuple);
} else if (declaration.getBindingName().equals(varB)) {
valueExtractorB = getValueExtractor(declaration, leftTuple);
} else if (declaration.getBindingName().equals(varC)) {
valueExtractorC = getValueExtractor(declaration, leftTuple);
}
}
| 411
| 134
| 545
|
<methods>public final java.lang.Object accumulate(java.lang.Object, java.lang.Object, BaseTuple, FactHandle, Declaration[], Declaration[], ValueResolver) ,public final java.lang.Object createContext() ,public final java.lang.Object createWorkingMemoryContext() ,public final Result_ getResult(java.lang.Object, java.lang.Object, BaseTuple, Declaration[], ValueResolver) ,public final ResultContainer_ init(java.lang.Object, java.lang.Object, BaseTuple, Declaration[], ValueResolver) ,public final boolean supportsReverse() ,public final boolean tryReverse(java.lang.Object, java.lang.Object, BaseTuple, FactHandle, java.lang.Object, Declaration[], Declaration[], ValueResolver) <variables>private final non-sealed Supplier<ResultContainer_> containerSupplier,private final non-sealed Function<ResultContainer_,Result_> finisher,private volatile boolean initialized
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-drools/src/main/java/org/optaplanner/constraint/streams/drools/common/TriRuleContext.java
|
TriRuleContext
|
newRuleBuilder
|
class TriRuleContext<A, B, C> extends AbstractRuleContext {
private final Variable<A> variableA;
private final Variable<B> variableB;
private final Variable<C> variableC;
public TriRuleContext(Variable<A> variableA, Variable<B> variableB, Variable<C> variableC,
ViewItem<?>... viewItems) {
super(viewItems);
this.variableA = Objects.requireNonNull(variableA);
this.variableB = Objects.requireNonNull(variableB);
this.variableC = Objects.requireNonNull(variableC);
}
public <Solution_> RuleBuilder<Solution_> newRuleBuilder(ToIntTriFunction<A, B, C> matchWeigher) {
ConsequenceBuilder<Solution_> consequenceBuilder =
(constraint, scoreImpacterGlobal) -> DSL.on(scoreImpacterGlobal, variableA, variableB, variableC)
.execute((drools, scoreImpacter, a, b, c) -> {
JustificationsSupplier justificationsSupplier =
scoreImpacter.getContext().isConstraintMatchEnabled()
? of(constraint, constraint.getJustificationMapping(),
constraint.getIndictedObjectsMapping(), a, b, c)
: null;
runConsequence(constraint, drools, scoreImpacter, matchWeigher.applyAsInt(a, b, c),
justificationsSupplier);
});
return assemble(consequenceBuilder);
}
public <Solution_> RuleBuilder<Solution_> newRuleBuilder(ToLongTriFunction<A, B, C> matchWeigher) {
ConsequenceBuilder<Solution_> consequenceBuilder =
(constraint, scoreImpacterGlobal) -> DSL.on(scoreImpacterGlobal, variableA, variableB, variableC)
.execute((drools, scoreImpacter, a, b, c) -> {
JustificationsSupplier justificationsSupplier =
scoreImpacter.getContext().isConstraintMatchEnabled()
? of(constraint, constraint.getJustificationMapping(),
constraint.getIndictedObjectsMapping(), a, b, c)
: null;
runConsequence(constraint, drools, scoreImpacter, matchWeigher.applyAsLong(a, b, c),
justificationsSupplier);
});
return assemble(consequenceBuilder);
}
public <Solution_> RuleBuilder<Solution_> newRuleBuilder(TriFunction<A, B, C, BigDecimal> matchWeigher) {<FILL_FUNCTION_BODY>}
public <Solution_> RuleBuilder<Solution_> newRuleBuilder() {
return newRuleBuilder((ToIntTriFunction<A, B, C>) (a, b, c) -> 1);
}
}
|
ConsequenceBuilder<Solution_> consequenceBuilder =
(constraint, scoreImpacterGlobal) -> DSL.on(scoreImpacterGlobal, variableA, variableB, variableC)
.execute((drools, scoreImpacter, a, b, c) -> {
JustificationsSupplier justificationsSupplier =
scoreImpacter.getContext().isConstraintMatchEnabled()
? of(constraint, constraint.getJustificationMapping(),
constraint.getIndictedObjectsMapping(), a, b, c)
: null;
runConsequence(constraint, drools, scoreImpacter, matchWeigher.apply(a, b, c),
justificationsSupplier);
});
return assemble(consequenceBuilder);
| 710
| 183
| 893
|
<methods><variables>private final non-sealed List<ViewItem<?>> viewItems
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-drools/src/main/java/org/optaplanner/constraint/streams/drools/common/TriTuple.java
|
TriTuple
|
toString
|
class TriTuple<A, B, C> implements FactTuple {
public final A a;
public final B b;
public final C c;
private final int hashCode;
public TriTuple(A a, B b, C c) {
this.a = a;
this.b = b;
this.c = c;
this.hashCode = Objects.hash(a, b, c);
}
@Override
public List<Object> asList() {
return Arrays.asList(a, b, c);
}
@Override
public boolean equals(final Object o) {
if (this == o) {
return true;
}
if (o == null || !Objects.equals(getClass(), o.getClass())) {
return false;
}
final TriTuple<?, ?, ?> other = (TriTuple<?, ?, ?>) o;
return hashCode == other.hashCode &&
Objects.equals(a, other.a) &&
Objects.equals(b, other.b) &&
Objects.equals(c, other.c);
}
@Override
public int hashCode() {
return hashCode;
}
@Override
public String toString() {<FILL_FUNCTION_BODY>}
}
|
return "TriTuple(" + a + ", " + b + ", " + c + ")";
| 338
| 26
| 364
|
<no_super_class>
|
apache_incubator-kie-optaplanner
|
incubator-kie-optaplanner/core/optaplanner-constraint-streams-drools/src/main/java/org/optaplanner/constraint/streams/drools/common/ValueExtractor.java
|
ValueExtractor
|
getTupleExtractor
|
class ValueExtractor<X> implements Function<BaseTuple, X> {
private static final UnaryOperator<BaseTuple> TUPLE_EXTRACTOR_OFFSET_1 = BaseTuple::getParent;
private static final UnaryOperator<BaseTuple> TUPLE_EXTRACTOR_OFFSET_2 = tuple -> tuple.getParent()
.getParent();
private static final UnaryOperator<BaseTuple> TUPLE_EXTRACTOR_OFFSET_3 = tuple -> tuple.getParent()
.getParent()
.getParent();
static UnaryOperator<BaseTuple> getTupleExtractor(Declaration declaration, BaseTuple leftTuple) {<FILL_FUNCTION_BODY>}
private final Declaration declaration;
private final UnaryOperator<BaseTuple> tupleExtractor;
public ValueExtractor(Declaration declaration, BaseTuple leftTuple) {
this.declaration = Objects.requireNonNull(declaration);
this.tupleExtractor = getTupleExtractor(declaration, leftTuple);
}
@Override
public X apply(BaseTuple tuple) {
BaseTuple extractedTuple = tupleExtractor == null ? tuple : tupleExtractor.apply(tuple);
return (X) declaration.getValue(null, extractedTuple.getFactHandle().getObject());
}
}
|
int offset = 0;
while (leftTuple.getIndex() != declaration.getTupleIndex()) {
leftTuple = leftTuple.getParent();
offset++;
}
switch (offset) {
case 0: // The tuple will be accessed directly to avoid a method call on the hot path.
return null;
case 1:
return TUPLE_EXTRACTOR_OFFSET_1;
case 2:
return TUPLE_EXTRACTOR_OFFSET_2;
case 3:
return TUPLE_EXTRACTOR_OFFSET_3;
default:
throw new UnsupportedOperationException("Impossible state: tuple delta offset (" + offset + ").");
}
| 339
| 186
| 525
|
<no_super_class>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.