chore: fix the comparator logic

Author: zepfred

src/main/java/ai/timefold/solver/benchmarks/examples/curriculumcourse/domain/Lecture.java

@@ -3,20 +3,21 @@
 import java.util.Set;
 
 import ai.timefold.solver.benchmarks.examples.common.domain.AbstractPersistable;
-import ai.timefold.solver.benchmarks.examples.curriculumcourse.domain.solver.LectureDifficultyWeightFactory;
-import ai.timefold.solver.benchmarks.examples.curriculumcourse.domain.solver.PeriodStrengthWeightFactory;
-import ai.timefold.solver.benchmarks.examples.curriculumcourse.domain.solver.RoomStrengthWeightFactory;
+import ai.timefold.solver.benchmarks.examples.curriculumcourse.domain.solver.LectureComparatorFactory;
+import ai.timefold.solver.benchmarks.examples.curriculumcourse.domain.solver.PeriodComparatorFactory;
+import ai.timefold.solver.benchmarks.examples.curriculumcourse.domain.solver.RoomComparatorFactory;
 import ai.timefold.solver.core.api.domain.entity.PlanningEntity;
 import ai.timefold.solver.core.api.domain.entity.PlanningPin;
 import ai.timefold.solver.core.api.domain.variable.PlanningVariable;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
 
-@PlanningEntity(comparatorFactoryClass = LectureDifficultyWeightFactory.class)
+@PlanningEntity(comparatorFactoryClass = LectureComparatorFactory.class)
 public class Lecture extends AbstractPersistable {
 
     private Course course;
     private int lectureIndexInCourse;
+    private int unavailablePeriodPenaltyCount = -1;
     private boolean pinned;
 
     // Planning variables: changes during planning, between score calculations.
@@ -67,7 +68,7 @@ public void setPinned(boolean pinned) {
         this.pinned = pinned;
     }
 
-    @PlanningVariable(comparatorFactoryClass = PeriodStrengthWeightFactory.class)
+    @PlanningVariable(comparatorFactoryClass = PeriodComparatorFactory.class)
     public Period getPeriod() {
         return period;
     }
@@ -76,7 +77,7 @@ public void setPeriod(Period period) {
         this.period = period;
     }
 
-    @PlanningVariable(comparatorFactoryClass = RoomStrengthWeightFactory.class)
+    @PlanningVariable(comparatorFactoryClass = RoomComparatorFactory.class)
     public Room getRoom() {
         return room;
     }
@@ -120,6 +121,19 @@ public int getTimeslotIndex() {
         return period.getTimeslot().getTimeslotIndex();
     }
 
+    @JsonIgnore
+    public int getUnavailablePeriodPenaltyCount(CourseSchedule schedule) {
+        if (unavailablePeriodPenaltyCount == -1) {
+            unavailablePeriodPenaltyCount = 0;
+            for (var penalty : schedule.getUnavailablePeriodPenaltyList()) {
+                if (penalty.getCourse().equals(course)) {
+                    unavailablePeriodPenaltyCount++;
+                }
+            }
+        }
+        return unavailablePeriodPenaltyCount;
+    }
+
     @Override
     public String toString() {
         return course + "-" + lectureIndexInCourse;

src/main/java/ai/timefold/solver/benchmarks/examples/curriculumcourse/domain/Period.java

@@ -5,13 +5,15 @@
 import ai.timefold.solver.benchmarks.examples.common.domain.AbstractPersistable;
 
 import com.fasterxml.jackson.annotation.JsonIdentityInfo;
+import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.annotation.ObjectIdGenerators;
 
 @JsonIdentityInfo(scope = Period.class, generator = ObjectIdGenerators.PropertyGenerator.class, property = "id")
 public class Period extends AbstractPersistable {
 
     private Day day;
     private Timeslot timeslot;
+    private int unavailablePeriodPenaltyCount = -1;
 
     public Period() {
     }
@@ -39,6 +41,19 @@ public void setTimeslot(Timeslot timeslot) {
         this.timeslot = timeslot;
     }
 
+    @JsonIgnore
+    public int getUnavailablePeriodPenaltyCount(CourseSchedule schedule) {
+        if (unavailablePeriodPenaltyCount == -1) {
+            unavailablePeriodPenaltyCount = 0;
+            for (var penalty : schedule.getUnavailablePeriodPenaltyList()) {
+                if (penalty.getPeriod().equals(this)) {
+                    unavailablePeriodPenaltyCount++;
+                }
+            }
+        }
+        return unavailablePeriodPenaltyCount;
+    }
+
     @Override
     public String toString() {
         return day + "-" + timeslot;

src/main/java/ai/timefold/solver/benchmarks/examples/curriculumcourse/domain/solver/LectureComparatorFactory.java

@@ -0,0 +1,21 @@
+package ai.timefold.solver.benchmarks.examples.curriculumcourse.domain.solver;
+
+import java.util.Comparator;
+
+import ai.timefold.solver.benchmarks.examples.common.domain.AbstractPersistable;
+import ai.timefold.solver.benchmarks.examples.curriculumcourse.domain.CourseSchedule;
+import ai.timefold.solver.benchmarks.examples.curriculumcourse.domain.Lecture;
+import ai.timefold.solver.core.api.domain.common.ComparatorFactory;
+
+public class LectureComparatorFactory implements ComparatorFactory<CourseSchedule, Lecture> {
+
+    @Override
+    public Comparator<Lecture> createComparator(CourseSchedule schedule) {
+        return Comparator.<Lecture> comparingInt(lecture -> lecture.getCurriculumSet().size())
+                .thenComparingInt(lecture -> lecture.getUnavailablePeriodPenaltyCount(schedule))
+                .thenComparingInt(lecture -> lecture.getCourse().getLectureSize())
+                .thenComparingInt(lecture -> lecture.getCourse().getStudentSize())
+                .thenComparingInt(lecture -> lecture.getCourse().getMinWorkingDaySize())
+                .thenComparingLong(AbstractPersistable::getId);
+    }
+}

src/main/java/ai/timefold/solver/benchmarks/examples/curriculumcourse/domain/solver/LectureDifficultyWeightFactory.java

@@ -0,0 +1,21 @@
+package ai.timefold.solver.benchmarks.examples.curriculumcourse.domain.solver;
+
+import java.util.Comparator;
+
+import ai.timefold.solver.benchmarks.examples.common.domain.AbstractPersistable;
+import ai.timefold.solver.benchmarks.examples.curriculumcourse.domain.CourseSchedule;
+import ai.timefold.solver.benchmarks.examples.curriculumcourse.domain.Period;
+import ai.timefold.solver.core.api.domain.common.ComparatorFactory;
+
+public class PeriodComparatorFactory implements ComparatorFactory<CourseSchedule, Period> {
+
+    @Override
+    public Comparator<Period> createComparator(CourseSchedule schedule) {
+        return Comparator
+                .<Period, Integer> comparing(period -> period.getUnavailablePeriodPenaltyCount(schedule),
+                        Comparator.reverseOrder())
+                .thenComparingInt(period -> period.getDay().getDayIndex())
+                .thenComparingInt(period -> period.getTimeslot().getTimeslotIndex())
+                .thenComparingLong(AbstractPersistable::getId);
+    }
+}

src/main/java/ai/timefold/solver/benchmarks/examples/curriculumcourse/domain/solver/PeriodComparatorFactory.java

@@ -0,0 +1,17 @@
+package ai.timefold.solver.benchmarks.examples.curriculumcourse.domain.solver;
+
+import java.util.Comparator;
+
+import ai.timefold.solver.benchmarks.examples.common.domain.AbstractPersistable;
+import ai.timefold.solver.benchmarks.examples.curriculumcourse.domain.CourseSchedule;
+import ai.timefold.solver.benchmarks.examples.curriculumcourse.domain.Room;
+import ai.timefold.solver.core.api.domain.common.ComparatorFactory;
+
+public class RoomComparatorFactory implements ComparatorFactory<CourseSchedule, Room> {
+
+    @Override
+    public Comparator<Room> createComparator(CourseSchedule schedule) {
+        return Comparator.comparingInt(Room::getCapacity)
+                .thenComparingLong(AbstractPersistable::getId);
+    }
+}