LocalDate.h

/*
 * MIT License
 * Copyright (c) 2018 Brian T. Park
 */
 
#ifndef ACE_TIME_LOCAL_DATE_H
#define ACE_TIME_LOCAL_DATE_H
 
#include <stdint.h>
#include <string.h> // strlen()
#include "Epoch.h"
#include "common/common.h"
 
class Print;
 
namespace ace_time {
 
class LocalDate {
  public:
    static const int16_t kInvalidYear = INT16_MIN;
 
    static const int16_t kMinYear = 0;
 
    static const int16_t kMaxYear = 10000;
 
    static const int32_t kInvalidEpochDays = INT32_MIN;
 
    static const int32_t kInvalidEpochSeconds = INT32_MIN;
 
    static const int64_t kInvalidUnixSeconds64 = INT64_MIN;
 
    static const acetime_t kMinEpochSeconds = INT32_MIN + 1;
 
    static const acetime_t kMaxEpochSeconds = INT32_MAX;
 
    static const uint8_t kMonday = 1;
 
    static const uint8_t kTuesday = 2;
 
    static const uint8_t kWednesday = 3;
 
    static const uint8_t kThursday = 4;
 
    static const uint8_t kFriday = 5;
 
    static const uint8_t kSaturday = 6;
 
    static const uint8_t kSunday = 7;
 
  // Utility functions
  public:
    static bool isLeapYear(int16_t year) {
      return ((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0);
    }
 
    static uint8_t daysInMonth(int16_t year, uint8_t month) {
      uint8_t days = sDaysInMonth[month - 1];
      return (month == 2 && isLeapYear(year)) ? days + 1 : days;
    }
 
    static bool isYearValid(int16_t year) {
      return kMinYear <= year && year <= kMaxYear;
    }
 
  // Factory methods.
  public:
    static LocalDate forComponents(
        int16_t year, uint8_t month, uint8_t day) {
      year = isYearValid(year) ? year : kInvalidYear;
      return LocalDate(year, month, day);
    }
 
    static LocalDate forEpochDays(int32_t epochDays) {
      int16_t year;
      uint8_t month;
      uint8_t day;
      if (epochDays == kInvalidEpochDays) {
        year = kInvalidYear;
        month = 0;
        day = 0;
      } else {
        // shift relative to Epoch::kInternalEpochYear
        epochDays += Epoch::daysToCurrentEpochFromInternalEpoch();
        ACE_TIME_EPOCH_CONVERTER::fromEpochDays(epochDays, year, month, day);
      }
      return forComponents(year, month, day);
    }
 
    static LocalDate forUnixDays(int32_t unixDays) {
      if (unixDays == kInvalidEpochDays) {
        return forError();
      }
 
      int32_t days = unixDays - Epoch::daysToCurrentEpochFromUnixEpoch();
      return forEpochDays(days);
    }
 
    static LocalDate forEpochSeconds(acetime_t epochSeconds) {
      if (epochSeconds == kInvalidEpochSeconds) {
        return forError();
      }
 
      // integer floor-division towards -infinity
      int32_t days = (epochSeconds < 0)
          ? (epochSeconds + 1) / 86400 - 1
          : epochSeconds / 86400;
      return forEpochDays(days);
    }
 
    static LocalDate forUnixSeconds64(int64_t unixSeconds) {
      if (unixSeconds == kInvalidUnixSeconds64) {
        return forError();
      } else {
        int64_t epochSeconds64 = unixSeconds
            - Epoch::secondsToCurrentEpochFromUnixEpoch64();
        int32_t days = (epochSeconds64 < 0)
            ? (epochSeconds64 + 1) / 86400 - 1
            : epochSeconds64 / 86400;
        return forEpochDays(days);
      }
    }
 
    static LocalDate forDateString(const char* dateString) {
      if (strlen(dateString) < kDateStringLength) {
        return forError();
      }
      return forDateStringChainable(dateString);
    }
 
    static LocalDate forDateStringChainable(const char*& dateString) {
      const char* s = dateString;
 
      // year (assumes 4 digit year)
      int16_t year = (*s++ - '0');
      year = 10 * year + (*s++ - '0');
      year = 10 * year + (*s++ - '0');
      year = 10 * year + (*s++ - '0');
 
      // '-'
      s++;
 
      // month
      uint8_t month = (*s++ - '0');
      month = 10 * month + (*s++ - '0');
 
      // '-'
      s++;
 
      // day
      uint8_t day = (*s++ - '0');
      day = 10 * day + (*s++ - '0');
 
      dateString = s;
      return forComponents(year, month, day);
    }
 
    static LocalDate forError() {
      return LocalDate(kInvalidYear, 0, 0);
    }
 
  // Instance methods.
  public:
    explicit LocalDate() = default;
 
    int16_t year() const { return mYear; }
 
    void year(int16_t year) { mYear = year; }
 
    uint8_t month() const { return mMonth; }
 
    void month(uint8_t month) { mMonth = month; }
 
    uint8_t day() const { return mDay; }
 
    void day(uint8_t day) { mDay = day; }
 
    uint8_t dayOfWeek() const {
      // The "year" starts in March to shift leap year calculation to end.
      int16_t y = year() - (mMonth < 3);
 
      // Each year shifts the day of week by one. Each leap year by one.
      // Except every 100 years. Unless divisible by 400.
      int16_t d = y + y/4 - y/100 + y/400 + sDayOfWeek[mMonth-1] + mDay;
 
      // 2000-01-01 was a Saturday=6, so set the offsets accordingly
      return (d < -1) ? (d + 1) % 7 + 8 : (d + 1) % 7 + 1;
    }
 
    bool isError() const {
      return mYear == kInvalidYear
          || mDay < 1 || mDay > 31
          || mMonth < 1 || mMonth > 12;
    }
 
    int32_t toEpochDays() const {
      if (isError()) return kInvalidEpochDays;
      int32_t days = ACE_TIME_EPOCH_CONVERTER::toEpochDays(mYear, mMonth, mDay)
          - Epoch::daysToCurrentEpochFromInternalEpoch();
      return days;
    }
 
    int32_t toUnixDays() const {
      if (isError()) return kInvalidEpochDays;
      return toEpochDays() + Epoch::daysToCurrentEpochFromUnixEpoch();
    }
 
    acetime_t toEpochSeconds() const {
      if (isError()) return kInvalidEpochSeconds;
      return (int32_t) 86400 * toEpochDays();
    }
 
    int64_t toUnixSeconds64() const {
      if (isError()) return kInvalidUnixSeconds64;
      return (int64_t) 86400 * toUnixDays();
    }
 
    int16_t daysUntil(uint8_t month, uint8_t day) const {
      int16_t y = year();
      LocalDate target = LocalDate::forComponents(y, month, day);
      if (this->compareTo(target) > 0) {
        target.year(y + 1);
      }
      return target.toEpochDays() - this->toEpochDays();
    }
 
    int8_t compareTo(const LocalDate& that) const {
      if (mYear < that.mYear) return -1;
      if (mYear > that.mYear) return 1;
      if (mMonth < that.mMonth) return -1;
      if (mMonth > that.mMonth) return 1;
      if (mDay < that.mDay) return -1;
      if (mDay > that.mDay) return 1;
      return 0;
    }
 
    void printTo(Print& printer) const;
 
    // Use default copy constructor and assignment operator.
    LocalDate(const LocalDate&) = default;
    LocalDate& operator=(const LocalDate&) = default;
 
  private:
    friend bool operator==(
        const LocalDate& a, const LocalDate& b);
 
    explicit LocalDate(int16_t year, uint8_t month, uint8_t day):
        mYear(year),
        mMonth(month),
        mDay(day) {}
 
  private:
    static const uint8_t kDateStringLength = 10;
 
    static const uint8_t sDayOfWeek[12];
 
    static const uint8_t sDaysInMonth[12];
 
    int16_t mYear; // [0,10000], INT16_MIN indicates error
    uint8_t mMonth; // [1, 12], 0 indicates error
    uint8_t mDay; // [1, 31], 0 indicates error
};
 
inline bool operator==(const LocalDate& a, const LocalDate& b) {
  return a.mDay == b.mDay
      && a.mMonth == b.mMonth
      && a.mYear == b.mYear;
}
 
inline bool operator!=(const LocalDate& a, const LocalDate& b) {
  return ! (a == b);
}
 
}
 
#endif