calendars/mtcore_calendars/time.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_TIME_HPP
#define MTCORE_CALENDARS_TIME_HPP
 
#include "mtcore.hpp"
 
namespace mtcore::calendars {
  enum class TimeValidationError {
    INVALID_HOUR,
    INVALID_MINUTE,
    INVALID_SECOND,
    INVALID_NANOSECOND,
    INVALID_FRACTION,
  };

  constexpr i32 NANOS_PER_SECOND = 1e9;
  constexpr i64 NANOS_PER_DAY = static_cast<i64>(NANOS_PER_SECOND) * 60 * 60 * 24;

  struct NanoSeconds;
  struct DayFraction;

  struct Segments {
    u8 hour   = 0;
    u8 minute = 0;
    u8 second = 0;
    u32 nano  = 0;

    [[nodiscard]] constexpr Result<void, TimeValidationError> try_validate() const {
      if (hour >= 24) {
        return error(TimeValidationError::INVALID_HOUR);
      }
 
      if (minute >= 60) {
        return error(TimeValidationError::INVALID_MINUTE);
      }
 
      if (second >= 60) {
        return error(TimeValidationError::INVALID_SECOND);
      }
 
      if (nano >= NANOS_PER_SECOND) {
        return error(TimeValidationError::INVALID_NANOSECOND);
      }
 
      return success();
    }
 
    [[nodiscard]] explicit constexpr operator NanoSeconds() const;
    [[nodiscard]] explicit constexpr operator DayFraction() const;
 
    [[nodiscard]] constexpr auto operator<=>(const Segments &o) const {
      if (hour != o.hour) {
        return hour <=> o.hour;
      }
      if (minute != o.minute) {
        return minute <=> o.minute;
      }
      if (second != o.second) {
        return second <=> o.second;
      }
      if (nano != o.nano) {
        return nano <=> o.nano;
      }
      return std::strong_ordering::equal;
    }
 
    [[nodiscard]] bool operator==(const Segments &o) const { return (*this <=> o) == std::strong_ordering::equal; }
    [[nodiscard]] bool operator!=(const Segments &o) const { return (*this <=> o) != std::strong_ordering::equal; }
    [[nodiscard]] bool operator<(const Segments &o) const { return (*this <=> o) == std::strong_ordering::less; }
    [[nodiscard]] bool operator>(const Segments &o) const { return (*this <=> o) == std::strong_ordering::greater; }
    [[nodiscard]] bool operator<=(const Segments &o) const {
      const auto cmp = (*this <=> o);
      return cmp == std::strong_ordering::equal || cmp == std::strong_ordering::less;
    }
    [[nodiscard]] bool operator>=(const Segments &o) const {
      const auto cmp = (*this <=> o);
      return cmp == std::strong_ordering::equal || cmp == std::strong_ordering::greater;
    }

    [[nodiscard]] constexpr f64 to_fraction_unchecked() const;
  };
 
  struct DayFraction {
    f64 frac;

    [[nodiscard]] constexpr Result<void, TimeValidationError> try_validate() const {
      if (!std::isfinite(frac)) {
        return error(TimeValidationError::INVALID_FRACTION);
      }
      if (frac < 0) {
        return error(TimeValidationError::INVALID_FRACTION);
      }
      if (frac >= 1) {
        return error(TimeValidationError::INVALID_FRACTION);
      }
      return success();
    }
 
    [[nodiscard]] explicit constexpr operator NanoSeconds() const;
    [[nodiscard]] explicit constexpr operator Segments() const;
 
    [[nodiscard]] constexpr auto operator<=>(const DayFraction &o) const { return frac <=> o.frac; }
 
    [[nodiscard]] bool operator==(const DayFraction &o) const {
      return (*this <=> o) == std::weak_ordering::equivalent;
    }
    [[nodiscard]] bool operator!=(const DayFraction &o) const {
      return (*this <=> o) != std::weak_ordering::equivalent;
    }
    [[nodiscard]] bool operator<(const DayFraction &o) const { return (*this <=> o) == std::weak_ordering::less; }
    [[nodiscard]] bool operator>(const DayFraction &o) const { return (*this <=> o) == std::weak_ordering::greater; }
    [[nodiscard]] bool operator<=(const DayFraction &o) const {
      const auto cmp = (*this <=> o);
      return cmp == std::weak_ordering::equivalent || cmp == std::weak_ordering::less;
    }
    [[nodiscard]] bool operator>=(const DayFraction &o) const {
      const auto cmp = (*this <=> o);
      return cmp == std::weak_ordering::equivalent || cmp == std::weak_ordering::greater;
    }
  };
 
  struct NanoSeconds {
    static constexpr auto max = NANOS_PER_DAY;
    u64 nano;

    [[nodiscard]] constexpr Result<void, TimeValidationError> try_validate() const {
      if (nano >= max) {
        return error(TimeValidationError::INVALID_NANOSECOND);
      }
      return success();
    }
 
    [[nodiscard]] explicit constexpr operator DayFraction() const;
    [[nodiscard]] explicit constexpr operator Segments() const;
 
    [[nodiscard]] constexpr auto operator<=>(const NanoSeconds &o) const { return nano <=> o.nano; }
 
    [[nodiscard]] bool operator==(const NanoSeconds &o) const { return (*this <=> o) == std::strong_ordering::equal; }
    [[nodiscard]] bool operator!=(const NanoSeconds &o) const { return (*this <=> o) != std::strong_ordering::equal; }
    [[nodiscard]] bool operator<(const NanoSeconds &o) const { return (*this <=> o) == std::strong_ordering::less; }
    [[nodiscard]] bool operator>(const NanoSeconds &o) const { return (*this <=> o) == std::strong_ordering::greater; }
    [[nodiscard]] bool operator<=(const NanoSeconds &o) const {
      const auto cmp = (*this <=> o);
      return cmp == std::strong_ordering::equal || cmp == std::strong_ordering::less;
    }
    [[nodiscard]] bool operator>=(const NanoSeconds &o) const {
      const auto cmp = (*this <=> o);
      return cmp == std::strong_ordering::equal || cmp == std::strong_ordering::greater;
    }
  };
 
  constexpr Segments::operator NanoSeconds() const {
    ensure(try_validate().is_success());
    const auto hours   = static_cast<u64>(this->hour);
    const auto minutes = 60 * hours + static_cast<u64>(this->minute);
    const auto seconds = 60 * minutes + static_cast<u64>(this->second);
    const auto nano    = seconds * NANOS_PER_SECOND + static_cast<u64>(this->nano);
    const auto res     = NanoSeconds{.nano = nano};
    ensure(res.try_validate().is_success());
    return res;
  }
  constexpr Segments::operator DayFraction() const {
    const auto nanos = static_cast<NanoSeconds>(*this);
    return static_cast<DayFraction>(nanos);
  }
 
  constexpr f64 Segments::to_fraction_unchecked() const {
    const auto hours     = static_cast<u64>(this->hour);
    const auto minutes   = 60 * hours + static_cast<u64>(this->minute);
    const auto seconds   = 60 * minutes + static_cast<u64>(this->second);
    const auto nano      = seconds * NANOS_PER_SECOND + static_cast<u64>(this->nano);
    const auto nanoFloat = static_cast<f80>(nano);
    const auto frac      = nanoFloat / static_cast<f80>(NANOS_PER_DAY);
    return static_cast<f64>(frac);
  }
 
  constexpr DayFraction::operator NanoSeconds() const {
    ensure(try_validate().is_success());
    const auto nanoSeconds = math::floor<f64, u64>(frac * NANOS_PER_DAY);
    const auto res         = NanoSeconds{.nano = nanoSeconds};
    ensure(res.try_validate().is_success());
    return res;
  }
 
  constexpr DayFraction::operator Segments() const {
    const auto nanos = static_cast<NanoSeconds>(*this);
    return static_cast<Segments>(nanos);
  }
 
  constexpr NanoSeconds::operator DayFraction() const {
    ensure(try_validate().is_success());
    const auto nano = static_cast<f80>(this->nano);
    const auto res  = DayFraction{.frac = static_cast<f64>(nano) / static_cast<f64>(NANOS_PER_DAY)};
    ensure(res.try_validate().is_success());
    return res;
  }
 
  constexpr NanoSeconds::operator Segments() const {
    ensure(try_validate().is_success());
 
    u64 val = this->nano;
 
    const auto nano = math::mod<u64, u64, u32>(val, NANOS_PER_SECOND);
    ensure(nano < NANOS_PER_SECOND);
    val /= NANOS_PER_SECOND;
 
    const auto seconds = math::mod<u64, u64, u8>(val, 60);
    ensure(seconds < 60);
    val /= 60;
 
    const auto minutes = math::mod<u64, u64, u8>(val, 60);
    ensure(minutes < 60);
    val /= 60;
 
    ensure(val < 24);
    const auto res = Segments{
      .hour   = static_cast<u8>(val),
      .minute = minutes,
      .second = seconds,
      .nano   = nano,
    };
 
    ensure(res.try_validate().is_success());
    return res;
  }
}  // namespace mtcore::calendars
 
namespace mtcore::io {
  template<>
  struct Formatter<calendars::NanoSeconds> {
    template<WriterImpl WI>
    static Result<size_t, typename Writer<WI>::ErrType> fmt(Writer<WI> &writer, const FormatOptions &,
                                                            const calendars::NanoSeconds &ns) {
      return io::print(writer, "{d}ns", ns.nano);
    }
  };
 
  template<>
  struct Formatter<calendars::DayFraction> {
    template<WriterImpl WI>
    static Result<size_t, typename Writer<WI>::ErrType> fmt(Writer<WI> &writer, const FormatOptions &,
                                                            const calendars::DayFraction &df) {
      return io::print(writer, "{.3}%(day)", df.frac * 100.);
    }
  };
 
  template<>
  struct Formatter<calendars::Segments> {
    template<WriterImpl WI>
    static Result<size_t, typename Writer<WI>::ErrType> fmt(Writer<WI> &writer, const FormatOptions &opts,
                                                            const calendars::Segments &seg) {
      if (opts.formatStr.empty()) {
        return io::print(writer, "{0<2;}:{0<2;}:{0<2;}.{0<9;}", seg.hour, seg.minute, seg.second, seg.nano);
      }
 
      size_t written       = 0;
      constexpr auto chars = ":. ";
      auto splits          = slices::split_one_of(slice_from(chars), opts.formatStr);
      Pair<Slice<const char>, Optional<char>> cur;
 
#define MTCORE_CAL_TIME_SEG_FMT_TRY_WRITE(FMTSTR, VAL)                                                                 \
  if (auto r = io::print(writer, (FMTSTR), (VAL)); r.is_error()) {                                                     \
    return r.error();                                                                                                  \
  }                                                                                                                    \
  else {                                                                                                               \
    written += r.value();                                                                                              \
  }
 
      while (splits.next().copy_if_present(cur)) {
        const auto [sub, sep] = cur;
        if (sep.has_value()) {
          if (auto r = writer.write(sep.value()); r.is_error()) {
            return r.error();
          }
        }
 
        if (sub.empty()) {
          continue;
        }
 
        if (str_equal(sub, "hh")) {
          MTCORE_CAL_TIME_SEG_FMT_TRY_WRITE("{0<2;}", math::amod(seg.hour, 12));
        }
        else if (str_equal(sub, "h")) {
          MTCORE_CAL_TIME_SEG_FMT_TRY_WRITE("{}", math::amod(seg.hour, 12));
        }
        else if (str_equal(sub, "HH")) {
          MTCORE_CAL_TIME_SEG_FMT_TRY_WRITE("{0<2;}", seg.hour);
        }
        else if (str_equal(sub, "H")) {
          MTCORE_CAL_TIME_SEG_FMT_TRY_WRITE("{}", seg.hour);
        }
        else if (str_equal(sub, "kk")) {
          MTCORE_CAL_TIME_SEG_FMT_TRY_WRITE("{0<2;}", math::mod(seg.hour, 12));
        }
        else if (str_equal(sub, "k")) {
          MTCORE_CAL_TIME_SEG_FMT_TRY_WRITE("{}", math::mod(seg.hour, 12));
        }
        else if (str_equal(sub, "KK")) {
          MTCORE_CAL_TIME_SEG_FMT_TRY_WRITE("{0<2;}", seg.hour + 1);
        }
        else if (str_equal(sub, "K")) {
          MTCORE_CAL_TIME_SEG_FMT_TRY_WRITE("{}", seg.hour + 1);
        }
        else if (str_equal(sub, "A") || str_equal(sub, "AA")) {
          MTCORE_CAL_TIME_SEG_FMT_TRY_WRITE("{}", seg.hour < 12 ? "AM" : "PM");
        }
        else if (str_equal(sub, "a") || str_equal(sub, "aa")) {
          MTCORE_CAL_TIME_SEG_FMT_TRY_WRITE("{}", seg.hour < 12 ? "am" : "pm");
        }
        else if (str_equal(sub, "aaa")) {
          MTCORE_CAL_TIME_SEG_FMT_TRY_WRITE("{}", seg.hour < 12 ? "a.m." : "p.m.");
        }
        else if (str_equal(sub, "AAA")) {
          MTCORE_CAL_TIME_SEG_FMT_TRY_WRITE("{}", seg.hour < 12 ? "A.M." : "P.M.");
        }
        else if (str_equal(sub, "aaaa")) {
          MTCORE_CAL_TIME_SEG_FMT_TRY_WRITE("{}", seg.hour < 12 ? "a" : "p");
        }
        else if (str_equal(sub, "AAAA")) {
          MTCORE_CAL_TIME_SEG_FMT_TRY_WRITE("{}", seg.hour < 12 ? "A" : "P");
        }
        else if (str_equal(sub, "mm")) {
          MTCORE_CAL_TIME_SEG_FMT_TRY_WRITE("{0<2;}", seg.minute);
        }
        else if (str_equal(sub, "m")) {
          MTCORE_CAL_TIME_SEG_FMT_TRY_WRITE("{}", seg.minute);
        }
        else if (str_equal(sub, "ss")) {
          MTCORE_CAL_TIME_SEG_FMT_TRY_WRITE("{0<2;}", seg.second);
        }
        else if (str_equal(sub, "s")) {
          MTCORE_CAL_TIME_SEG_FMT_TRY_WRITE("{}", seg.second);
        }
        else if (str_equal(sub, "S")) {
          MTCORE_CAL_TIME_SEG_FMT_TRY_WRITE("{}", seg.nano);
        }
        else if (str_equal(sub, "SS")) {
          MTCORE_CAL_TIME_SEG_FMT_TRY_WRITE("{0<2;}", seg.nano);
        }
        else if (str_equal(sub, "SSS")) {
          MTCORE_CAL_TIME_SEG_FMT_TRY_WRITE("{0<3;}", seg.nano);
        }
        else if (str_equal(sub, "SSSS")) {
          MTCORE_CAL_TIME_SEG_FMT_TRY_WRITE("{0<4;}", seg.nano);
        }
        else if (str_equal(sub, "SSSSS")) {
          MTCORE_CAL_TIME_SEG_FMT_TRY_WRITE("{0<5;}", seg.nano);
        }
        else if (str_equal(sub, "SSSSSS")) {
          MTCORE_CAL_TIME_SEG_FMT_TRY_WRITE("{0<6;}", seg.nano);
        }
        else if (str_equal(sub, "SSSSSSS")) {
          MTCORE_CAL_TIME_SEG_FMT_TRY_WRITE("{0<7;}", seg.nano);
        }
        else if (str_equal(sub, "SSSSSSSS")) {
          MTCORE_CAL_TIME_SEG_FMT_TRY_WRITE("{0<8;}", seg.nano);
        }
        else if (str_equal(sub, "SSSSSSSSS")) {
          MTCORE_CAL_TIME_SEG_FMT_TRY_WRITE("{0<9;}", seg.nano);
        }
        else {
          MTCORE_CAL_TIME_SEG_FMT_TRY_WRITE("{}", sub);
        }
      }
 
      return success(written);
    }
  };  // namespace mtcore::io
}  // namespace mtcore::io
 
#endif  // MTCORE_CALENDARS_TIME_HPP