Почему ConstraintMatchTotal не может добавить constraintMatch, когда проблема связана с предложением.drl 'или'?

Question

В расширении кода от OptaPlanner медсестра образец кода. Что вызывает ошибку "constraintMatchTotal не удалось добавить ошибку (Недопустимое состояние?)", Которая может быть связана с разбором правила.drl с предложением "или", пожалуйста? Это происходит немедленно при импорте данных в набор правил на основе.drl... но НЕ выдает ошибку, если любое из двух предложений 'или' закомментировано. Я считаю, что, поскольку они по отдельности являются приемлемыми, система должна обрабатывать их в настройках "или".

Ниже приведено правило, за которым следует ошибка и объект домена, используемый в предложении 'или'. Я подтвердил, что:

• Если я закомментирую 'или' и предложение BoundaryDate над ним, программа загрузится и запустится.
• Если я закомментирую 'или' и предложение BoundaryDate под ним, программа загрузится и запустится.
• Если я оставлю оба на месте, ошибка (ниже правила) выдается сразу.
• Кроме того, если я вставлю это предложение в условие 2nd BoundaryDate (после 'или'), программа загрузится и запустится:preferredSequenceStart == true,

Правило.drl:

rule "Highlight irregular shifts"
when
    EmployeeWorkSameShiftTypeSequence(
        employee != null,        
        $firstDayIndex : firstDayIndex,
        $lastDayIndex : lastDayIndex,
        $employee : employee,
        $dayLength : dayLength)

    (
    BoundaryDate(
        dayIndex == $firstDayIndex,
        preferredSequenceStart == false     // does not start on a boundary start date
        )
    or                                      // or
    BoundaryDate(
        dayIndex == $firstDayIndex,
        $dayLength != preferredCoveringLength   // is incorrect length for exactly one block
        )
    )

    StaffRosterParametrization($lastDayIndex >= planningWindowStartDayIndex)    // ignore if assignment is in (fixed) prior data            

    // non-functional identification drives desired indictment display on ShiftAssignment planning objects
    ShiftAssignment(employee == $employee, shiftDateDayIndex >= $firstDayIndex, shiftDateDayIndex <= $lastDayIndex)

then
    scoreHolder.addSoftConstraintMatch(kcontext, -1);
end

Exception executing consequence for rule "Highlight irregular shifts" in westgranite.staffrostering.solver: java.lang.IllegalStateException: The constraintMatchTotal (westgranite.staffrostering.solver/Highlight irregular shifts=0hard/-274soft) could not add constraintMatch (westgranite.staffrostering.solver/Highlight irregular shifts/[2020-01-02/D/6, 2018-12-25 - 2020-01-06, 2020-01-02, ...[продолжает список соответствий ограничений]

BoundaryData.java ниже, поэтому методы, вызываемые из правила, видны:

package westgranite.staffrostering.domain;

import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import com.thoughtworks.xstream.annotations.XStreamAlias;

import westgranite.common.domain.AbstractPersistable;

@XStreamAlias("BoundaryDate")
public class BoundaryDate extends AbstractPersistable {
    /**
     * 
     */
    private static final long serialVersionUID = -7393276689810490427L;

    private static final DateTimeFormatter LABEL_FORMATTER = DateTimeFormatter.ofPattern("E d MMM");

    private int dayIndex; 
    private LocalDate date;

    private boolean preferredSequenceStart; // true means "this date is a preferred start to assignment sequences"
    private boolean preferredSequenceEnd;   // true means "this date is a preferred end for assignment sequences"
    private int nextPreferredStartDayIndex; // MAX_VALUE means "none"; if preferredSequenceStart is true, then this ref is still to the FUTURE next pref start date
    private int prevPreferredStartDayIndex; // MIN_VALUE means "none"; if preferredSequenceStart is true, then this ref is still to the PREVIOUS next pref start date

    // magic value that is beyond reasonable dayIndex range and still allows delta of indices to be an Integer
    public static final int noNextPreferredDayIndex = Integer.MAX_VALUE/3;
    public static final int noPrevPreferredDayIndex = Integer.MIN_VALUE/3;

    public int getDayIndex() {
        return dayIndex;
    }

    public void setDayIndex(int dayIndex) {
        this.dayIndex = dayIndex;
    }

    public LocalDate getDate() {
        return date;
    }

    public void setDate(LocalDate date) {
        this.date = date;
    }

    public boolean isPreferredSequenceStart() {
        return preferredSequenceStart;
    }

    public void setPreferredSequenceStart(boolean preferredSequenceStart) {
        this.preferredSequenceStart = preferredSequenceStart;
    }

    public boolean isPreferredSequenceEnd() {
        return preferredSequenceEnd;
    }

    public void setPreferredSequenceEnd(boolean preferredSequenceEnd) {
        this.preferredSequenceEnd = preferredSequenceEnd;
    }

    public int getNextPreferredStartDayIndex() {
        return nextPreferredStartDayIndex;
    }

    public void setNextPreferredStartDayIndex(int nextPreferredStartDayIndex) {
        this.nextPreferredStartDayIndex = nextPreferredStartDayIndex;
    }

    public int getPrevPreferredStartDayIndex() {
        return prevPreferredStartDayIndex;
    }

    public void setPrevPreferredStartDayIndex(int prevPreferredStartDayIndex) {
        this.prevPreferredStartDayIndex = prevPreferredStartDayIndex;
    }

    // ===================== COMPLEX METHODS ===============================
    public int getCurrOrPrevPreferredStartDayIndex() {
        return (isPreferredSequenceStart() ? dayIndex : prevPreferredStartDayIndex);
    }

    public int getCurrOrNextPreferredStartDayIndex() {
        return (isPreferredSequenceStart() ? dayIndex : nextPreferredStartDayIndex);
    }

    public int getCurrOrPrevPreferredEndDayIndex() {
        return (isPreferredSequenceEnd() ? dayIndex : (isPreferredSequenceStart() ? dayIndex-1 : prevPreferredStartDayIndex-1));
    }

    public int getCurrOrNextPreferredEndDayIndex() {
        return (isPreferredSequenceEnd() ? dayIndex : nextPreferredStartDayIndex-1);
    }

    public boolean isNoNextPreferred() {
        return getNextPreferredStartDayIndex() == noNextPreferredDayIndex;
    }

    public boolean isNoPrevPreferred() {
        return getPrevPreferredStartDayIndex() == noPrevPreferredDayIndex;
    }

    /**
     * @return if this is a preferred start date, then the sequence length that will fill from this date through the next end date; otherwise the days filling the past preferred start date through next end date
     */
    public int getPreferredCoveringLength() {
        if (isPreferredSequenceStart()) {
            return nextPreferredStartDayIndex - dayIndex;
        }
        return nextPreferredStartDayIndex - prevPreferredStartDayIndex;
    }

    /**
     * @return if this is a preferred start boundary, then "today", else day of most recent start boundary
     */
    public DayOfWeek getPreferredStartDayOfWeek() {
        if (isPreferredSequenceStart()) {
            return getDayOfWeek();
        }
        if (isNoPrevPreferred()) {
            throw new IllegalStateException("No prev preferred day of week available for " + toString());
        }
        return date.minusDays(dayIndex - getPrevPreferredStartDayIndex()).getDayOfWeek();
    }

    public DayOfWeek getPreferredEndDayOfWeek() {
        if (isPreferredSequenceEnd()) {
            return getDayOfWeek();
        }
        if (isNoNextPreferred()) {
            throw new IllegalStateException("No next preferred day of week available for " + toString());
        }
        return date.plusDays((getNextPreferredStartDayIndex()-1) - dayIndex).getDayOfWeek();
    }

    public DayOfWeek getDayOfWeek() {
        return date.getDayOfWeek();
    }

    public int getMostRecentDayIndexOf(DayOfWeek targetDayOfWeek) {
        return dayIndex - getBackwardDaysToReach(targetDayOfWeek);
    }

    public int getUpcomingDayIndexOf(DayOfWeek targetDayOfWeek) {
        return dayIndex + getForwardDaysToReach(targetDayOfWeek);
    }

    public LocalDate getMostRecentDateOf(DayOfWeek targetDayOfWeek) {
        return date.minusDays(getBackwardDaysToReach(targetDayOfWeek));
    }

    public LocalDate getUpcomingDateOf(DayOfWeek targetDayOfWeek) {
        return date.plusDays(getForwardDaysToReach(targetDayOfWeek));
    }

    public int getForwardDaysToReach(DayOfWeek targetDayOfWeek) {
        return getForwardDaysToReach(this.getDayOfWeek(), targetDayOfWeek);
    }

    public static int getForwardDaysToReach(DayOfWeek startDayOfWeek, DayOfWeek targetDayOfWeek) {
        if (startDayOfWeek == targetDayOfWeek) {
            return 0;
        }
        int forwardDayCount = 1;
        while (startDayOfWeek.plus(forwardDayCount) != targetDayOfWeek) {
            forwardDayCount++;

            if (forwardDayCount > 10) {
                throw new IllegalStateException("counting forward in days from " + startDayOfWeek + " never found target day of week: " + targetDayOfWeek);
            }
        }
        return forwardDayCount;
    }

    public int getBackwardDaysToReach(DayOfWeek targetDayOfWeek) {
        return getBackwardDaysToReach(this.getDayOfWeek(), targetDayOfWeek);
    }

    public static int getBackwardDaysToReach(DayOfWeek startDayOfWeek, DayOfWeek targetDayOfWeek) {
        if (startDayOfWeek == targetDayOfWeek) {
            return 0;
        }
        int backwardDayCount = 1;
        while (startDayOfWeek.minus(backwardDayCount) != targetDayOfWeek) {
            backwardDayCount++;

            if (backwardDayCount > 10) {
                throw new IllegalStateException("counting backward in days from " + startDayOfWeek + " never found target day of week: " + targetDayOfWeek);
            }
        }
        return backwardDayCount;
    }

    public String getLabel() {
        return date.format(LABEL_FORMATTER);
    }

    @Override
    public String toString() {
        return date.format(DateTimeFormatter.ISO_DATE);
    }

}

Answer 1

Если один и тот же объект, проверяемый в правиле, может совпадать в нескольких частях условия 'или', то Optaplanner выдает это исключение IllegalStateException, по крайней мере, до 7.15.0. Смотрите подробности, изученные в optaplanner jira 1433.

Обходной путь - всегда добавлять термины в более поздние термины выражений "или", которые гарантируют, что сопоставляемый объект не может быть тем же, который соответствовал более ранним частям "или". Для первоначальной публикации, приведенной выше, 'selectedSequenceStart == true' достигло этого исключения.

Обратите внимание, что использование ключевого слова "exist" в терминах "or" может вызвать проблемы с этим обходным решением; Старайтесь избегать использования "существует" в этой ситуации.