fixed.hpp

Go to the documentation of this file.

/*
 
Copyright 2025 Matthew Tolman
 
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
 
   http://www.apache.org/licenses/LICENSE-2.0
 
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
 
*/
 
#ifndef MTCORE_CALENDARS_FIXED_HPP
#define MTCORE_CALENDARS_FIXED_HPP
 
#include "mtcore.hpp"
#include "mtcore_calendars/core.hpp"
#include "mtcore_calendars/epochs.hpp"
#include "mtcore_calendars/traits.hpp"
#include <string_view>


namespace mtcore::calendars {
  struct Fixed {
    static constexpr auto EPOCH            = FIXED_EPOCH;
    static constexpr std::string_view name = "FIXED";
    i32 day;

    [[nodiscard]] constexpr auto operator<=>(const Fixed &o) const { return day <=> o.day; }
    [[nodiscard]] constexpr auto operator==(const Fixed &o) const -> bool {
      auto cmp = *this <=> o;
      return cmp == decltype(cmp)::equivalent;
    }
    [[nodiscard]] constexpr auto operator!=(const Fixed &o) const -> bool {
      auto cmp = *this <=> o;
      return cmp != decltype(cmp)::equivalent;
    }
    [[nodiscard]] constexpr auto operator<=(const Fixed &o) const -> bool {
      auto cmp = *this <=> o;
      return cmp == decltype(cmp)::equivalent || cmp == decltype(cmp)::less;
    }
    [[nodiscard]] constexpr auto operator>=(const Fixed &o) const -> bool {
      auto cmp = *this <=> o;
      return cmp == decltype(cmp)::equivalent || cmp == decltype(cmp)::greater;
    }
    [[nodiscard]] constexpr auto operator<(const Fixed &o) const -> bool {
      auto cmp = *this <=> o;
      return cmp == decltype(cmp)::less;
    }
    [[nodiscard]] constexpr auto operator>(const Fixed &o) const -> bool {
      auto cmp = *this <=> o;
      return cmp == decltype(cmp)::greater;
    }

    [[nodiscard]] static constexpr Fixed from_fixed(const Fixed &o) { return o; }
    [[nodiscard]] constexpr Fixed to_fixed() const { return *this; }

    [[nodiscard]] constexpr DayOfWeek day_of_week() const {
      const i32 d    = day - FIXED_EPOCH - static_cast<i32>(DayOfWeek::Sunday);
      const auto dow = math::mod(d, 7);
      ensure(dow >= 0 && dow < 7);
      return static_cast<DayOfWeek>(dow);
    }

    [[nodiscard]] constexpr Fixed add_days(const i32 days) const { return {day + days}; }

    [[nodiscard]] constexpr Fixed sub_days(const i32 days) const { return {day - days}; }

    [[nodiscard]] constexpr i32 day_difference(const Fixed &other) const { return day - other.day; }

    [[nodiscard]] constexpr Fixed nth_week_day(const i32 n, const DayOfWeek k) const {
      if (n > 0) {
        return day_of_week_before(k).add_days(7 * n);
      }
      else if (n < 0) {
        return day_of_week_after(k).add_days(7 * n);
      }
      else {
        return *this;
      }
    }

    [[nodiscard]] constexpr Fixed day_of_week_before(const DayOfWeek k) const {
      return sub_days(1).day_of_week_on_or_before(k);
    }

    [[nodiscard]] constexpr Fixed day_of_week_after(const DayOfWeek k) const {
      return add_days(7).day_of_week_on_or_before(k);
    }

    [[nodiscard]] constexpr Fixed day_of_week_nearest(const DayOfWeek k) const {
      return add_days(3).day_of_week_on_or_before(k);
    }

    [[nodiscard]] constexpr Fixed day_of_week_on_or_before(const DayOfWeek k) const {
      const auto dayOfWeekPrev = (Fixed{
                                    .day = day - static_cast<i32>(k),
                                  })
                                   .day_of_week();
      return Fixed{.day = day - static_cast<i32>(dayOfWeekPrev)};
    }

    [[nodiscard]] constexpr Fixed day_of_week_on_or_after(const DayOfWeek k) const {
      return add_days(6).day_of_week_on_or_before(k);
    }

    [[nodiscard]] constexpr Fixed first_week_day(const DayOfWeek k) const { return nth_week_day(1, k); }

    [[nodiscard]] constexpr Fixed last_week_day(const DayOfWeek k) const { return nth_week_day(-1, k); }

    [[nodiscard]] auto positions_in_range(Allocator &alloc, const Fixed &end, i32 pthMoment, i32 cDayCycle,
                                          i32 delta) const -> Result<mtcore::ArrayList<Fixed>, AllocationError> {
      auto capacity =
        std::max<size_t>(1, static_cast<size_t>(count_positions_in_range(end, pthMoment, cDayCycle, delta)));
      ArrayList<Fixed> res;
      if (const auto r = res.init(alloc, capacity); r.is_error()) {
        return r.error();
      }
      auto start = this->day;
      while (true) {
        auto curDate = math::mod_range<i32>(pthMoment - delta, start, start + cDayCycle);
        if (curDate >= end.day) {
          return success(res);
        }
        ensure(res.push({curDate}).is_success());
        start += cDayCycle;
      }
    }

    [[nodiscard]] constexpr i32 day_of_m_cycle(i32 m, i32 offset) const { return math::mod(day - offset, m); }

    [[nodiscard]] constexpr auto kth_day_of_m_cycle_on_or_before(i32 k, i32 m, i32 offset) const noexcept -> Fixed {
      const auto mCycleDay = sub_days(k).day_of_m_cycle(m, offset);
      return sub_days(mCycleDay);
    }

    [[nodiscard]] constexpr auto kth_day_of_m_cycle_before(i32 k, i32 m, i32 offset) const noexcept -> Fixed {
      return sub_days(1).kth_day_of_m_cycle_on_or_before(k, m, offset);
    }

    [[nodiscard]] constexpr auto kth_day_of_m_cycle_on_or_after(i32 k, i32 m, i32 offset) const noexcept -> Fixed {
      return add_days(m - 1).kth_day_of_m_cycle_on_or_before(k, m, offset);
    }

    [[nodiscard]] constexpr auto kth_day_of_m_cycle_after(i32 k, i32 m, i32 offset) const noexcept -> Fixed {
      return add_days(m).kth_day_of_m_cycle_on_or_before(k, m, offset);
    }

    [[nodiscard]] constexpr auto kth_day_of_m_cycle_nearest(i32 k, i32 m, i32 offset) const noexcept -> Fixed {
      return add_days(m / 2).kth_day_of_m_cycle_on_or_before(k, m, offset);
    }
 
  private:
    [[nodiscard]] constexpr auto count_positions_in_range(const Fixed &end, i32 pthMoment, i32 cDayCycle,
                                                          i32 delta) const -> size_t {
      size_t res = 0;
      auto start = this->day;
      while (true) {
        auto curDate = math::mod_range<int64_t>(pthMoment - delta, start, start + cDayCycle);
        if (curDate >= end.day) {
          return res;
        }
        ++res;
        start += cDayCycle;
      }
    }
  };

  struct Moment {
    static constexpr auto EPOCH            = FIXED_EPOCH;
    static constexpr std::string_view name = "MOMENT";
    f64 dayAndTime;

    [[nodiscard]] constexpr bool is_valid() const { return std::isfinite(dayAndTime); }

    [[nodiscard]] constexpr Moment to_moment() const { return *this; }
    [[nodiscard]] constexpr static Moment from_moment(Moment m) { return m; }

    [[nodiscard]] constexpr auto operator<=>(const Moment &o) const { return dayAndTime <=> o.dayAndTime; }

    [[nodiscard]] constexpr static Fixed moment_to_fixed(const Moment &m) {
      return {math::floor<f64, i32>(m.dayAndTime)};
    }

    [[nodiscard]] constexpr static Moment reconstruct(const Fixed &f, const Moment &m) {
      const auto mt = m.dayAndTime - math::floor<f64, i32>(m.dayAndTime);
      return {static_cast<f64>(f.day) + mt};
    }

    [[nodiscard]] constexpr Moment add_days(const i32 days) const { return {dayAndTime + days}; }

    [[nodiscard]] constexpr Moment sub_days(const i32 days) const { return {dayAndTime - days}; }

    [[nodiscard]] constexpr i32 day_difference(const Moment &other) const {
      return math::floor<f64, i32>(dayAndTime - other.dayAndTime);
    }
  };
}  // namespace mtcore::calendars
 
#endif  // MTCORE_CALENDARS_FIXED_HPP