Initial commit

core/utils/day_manager.cpp

@@ -0,0 +1,246 @@
+#include "day_manager.h"
+
+#include <QRandomGenerator>
+#include <algorithm>
+
+DayManager::DayManager(const QTime &begin, const QTime &end) : DayManager() {
+  addAvailableSlot(begin, end);
+}
+
+void DayManager::addAvailableSlot(const QTime &begin, const QTime &end) {
+  if (!begin.isValid() || !end.isValid() || begin >= end) {
+    qWarning() << "DayManager::addAvailableSlot: begin or end is invalid";
+    return;
+  }
+  if (begin.msecsTo(end) >= minDurationMs_) {
+    availableSlots_.insert(begin, end);
+  }
+}
+
+QPair<QTime, QTime> DayManager::reserve(const QTime &duration) {
+  if (!duration.isValid()) {
+    qWarning() << "DayManager::reserve: duration is invalid";
+    return {};
+  }
+
+  const qint64 requiredMs = duration.msecsSinceStartOfDay();
+  if (requiredMs <= 0) {
+    qWarning() << "DayManager::reserve: duration is invalid";
+    return {};
+  }
+
+  QPair<QTime, QTime> result = reserveImpl(requiredMs);
+  if (!isAvailable(result.first, result.second)) {
+    return {};
+  }
+
+  ++createdRecords_;
+  return result;
+}
+
+template <typename... Times>
+bool DayManager::isAvailable(const QTime &first, const Times &...others) const {
+  static const auto isAvailable = [](const QTime &time) {
+    return time.isValid();
+  };
+  return isAvailable(first) && isAvailable(others...);
+}
+
+QList<std::reference_wrapper<const QTime>>
+DayManager::availableSlots(qint64 requiredMs) const {
+  QList<std::reference_wrapper<const QTime>> result;
+  for (auto const &[begin, end] : availableSlots_.asKeyValueRange()) {
+    if (begin.msecsTo(end) >= requiredMs) {
+      result.append(begin);
+    }
+  }
+  return result;
+}
+
+QPair<QTime, QTime> DayManager::reserveAvailableSlotLeft(QTime begin,
+                                                         qint64 requiredMs) {
+  QTime end = availableSlots_.value(begin);
+
+  QTime reservedEnd = begin.addMSecs(requiredMs);
+  if (reservedEnd < end) {
+    addAvailableSlot(reservedEnd, end);
+  }
+  availableSlots_.remove(begin);
+
+  return {begin, reservedEnd};
+}
+
+QPair<QTime, QTime> DayManager::reserveAvailableSlotRight(QTime begin,
+                                                          qint64 requiredMs) {
+  QTime end = availableSlots_.value(begin);
+  availableSlots_.remove(begin);
+
+  QTime reservedBegin = end.addMSecs(-requiredMs);
+  if (reservedBegin > begin) {
+    addAvailableSlot(begin, reservedBegin);
+  }
+
+  return {reservedBegin, end};
+}
+
+QPair<QTime, QTime> DayManager::reserveAvailableSlotRandom(QTime begin,
+                                                           qint64 requiredMs) {
+  QTime end = availableSlots_.value(begin);
+  if (!end.isValid()) {
+    qCritical() << "DayManager::reserveAvailableSlotRandom: end is invalid";
+  }
+
+  qint64 beginMs = begin.msecsSinceStartOfDay();
+  qint64 endMs = end.msecsSinceStartOfDay();
+
+  // x <= bounded(x, y) < y
+  qint64 highestMs = endMs - requiredMs;
+  qint64 startTimeMs =
+      QRandomGenerator::global()->bounded(beginMs, highestMs + 1);
+
+  if (startTimeMs == beginMs) {
+    return reserveAvailableSlotLeft(begin, requiredMs);
+  }
+  if (startTimeMs == highestMs) {
+    return reserveAvailableSlotRight(begin, requiredMs);
+  }
+
+  availableSlots_.remove(begin);
+
+  QTime reservedBegin = QTime::fromMSecsSinceStartOfDay(startTimeMs);
+  QTime reservedEnd = QTime::fromMSecsSinceStartOfDay(startTimeMs + requiredMs);
+
+  addAvailableSlot(begin, reservedBegin);
+  addAvailableSlot(reservedEnd, end);
+
+  return {reservedBegin, reservedEnd};
+}
+
+QPair<QTime, QTime> DayManager::reserveAvailableSlot(QTime begin,
+                                                     qint64 requiredMs) {
+  switch (startTimeMode_) {
+  case StartTimeMode::Left:
+    return reserveAvailableSlotLeft(begin, requiredMs);
+  case StartTimeMode::Random:
+    return reserveAvailableSlotRandom(begin, requiredMs);
+  case StartTimeMode::Right:
+    return reserveAvailableSlotRight(begin, requiredMs);
+  default:
+    qWarning() << "DayManager::reserve: unknown start time mode";
+    return {};
+  }
+}
+
+QPair<QTime, QTime> DayManager::reserveImplMaximal(qint64 requiredMs) {
+  auto keys = availableSlots(requiredMs);
+  if (keys.isEmpty()) {
+    return {};
+  }
+
+  QTime begin = *std::max_element(
+      keys.begin(), keys.end(), [this](const auto &largest, const auto &other) {
+        return duration(largest) < duration(other);
+      });
+  return reserveAvailableSlot(begin, requiredMs);
+}
+
+QPair<QTime, QTime> DayManager::reserveImplMinimal(qint64 requiredMs) {
+  auto keys = availableSlots(requiredMs);
+  if (keys.isEmpty()) {
+    return {};
+  }
+
+  QTime begin =
+      *std::min_element(keys.begin(), keys.end(),
+                        [this](const QTime &smallest, const QTime &other) {
+                          return duration(smallest) < duration(other);
+                        });
+  return reserveAvailableSlot(begin, requiredMs);
+}
+
+QPair<QTime, QTime> DayManager::reserveImplQuick(qint64 requiredMs) {
+  for (auto const &[begin, end] : availableSlots_.asKeyValueRange()) {
+    if (begin.msecsTo(end) >= requiredMs) {
+      return reserveAvailableSlot(begin, requiredMs);
+    }
+  }
+
+  return {};
+}
+
+QPair<QTime, QTime> DayManager::reserveImplRandom(qint64 requiredMs) {
+  auto keys = availableSlots(requiredMs);
+  if (keys.isEmpty()) {
+    return {};
+  }
+
+  QRandomGenerator *g = QRandomGenerator::global();
+  QTime begin = keys.at(g->bounded(keys.size()));
+  return reserveAvailableSlot(begin, requiredMs);
+}
+
+QPair<QTime, QTime> DayManager::reserveImpl(qint64 requiredMs) {
+  switch (slotSelectionMode_) {
+  case SlotSelectionMode::Quick:
+    return DayManager::reserveImplQuick(requiredMs);
+  case SlotSelectionMode::Maximal:
+    return DayManager::reserveImplMaximal(requiredMs);
+  case SlotSelectionMode::Minimal:
+    return DayManager::reserveImplMinimal(requiredMs);
+  case SlotSelectionMode::Random:
+    return DayManager::reserveImplRandom(requiredMs);
+  default:
+    qWarning() << "DayManager::reserve: unknown reserve mode";
+    return {};
+  }
+}
+
+void DayManager::setMinDuration(const QTime &duration) {
+  if (!duration.isValid()) {
+    qWarning() << "DayManager::setMinDuration: duration is invalid";
+    return;
+  }
+
+  minDurationMs_ = duration.msecsSinceStartOfDay();
+}
+
+qsizetype DayManager::calculatePossibleReservations(qint64 requiredMs) const {
+  auto keys = availableSlots(requiredMs);
+  return std::accumulate(keys.begin(), keys.end(), 0,
+                         [this, requiredMs](qsizetype sum, const QTime &key) {
+                           qint64 durationMs =
+                               duration(key).msecsSinceStartOfDay();
+                           return sum + std::floor(durationMs / requiredMs);
+                         });
+}
+
+QTime DayManager::duration() const {
+  if (availableSlots_.isEmpty()) {
+    // qWarning() << "DayManager::duration: no available slots";
+    return {};
+  }
+
+  const auto &kvRange = availableSlots_.asKeyValueRange();
+  auto f = [this](qint64 sum, const auto &kv) -> qint64 {
+    auto const &[begin, end] = kv;
+    return sum + begin.msecsTo(end);
+  };
+  qint64 sum = std::accumulate(kvRange.begin(), kvRange.end(), 0, f);
+
+  return QTime::fromMSecsSinceStartOfDay(sum);
+}
+
+QTime DayManager::duration(const QTime &begin) const {
+  if (!begin.isValid()) {
+    qWarning() << "DayManager::duration: begin is invalid";
+    return {};
+  }
+
+  const QTime &end = availableSlots_.value(begin);
+  if (!end.isValid()) {
+    qWarning() << "DayManager::duration: end is invalid";
+    return {};
+  }
+
+  return end.addMSecs(-begin.msecsSinceStartOfDay());
+}