DateTuple.h

/*
 * MIT License
 * Copyright (c) 2019 Brian T. Park
 */
 
#ifndef ACE_TIME_DATE_TUPLE_H
#define ACE_TIME_DATE_TUPLE_H
 
#include <stdint.h> // uint8_t
#include "common/logging.h"
#include "local_date_mutation.h"
 
#ifndef ACE_TIME_EXTENDED_ZONE_PROCESSOR_DEBUG
#define ACE_TIME_EXTENDED_ZONE_PROCESSOR_DEBUG 0
#endif
 
namespace ace_time {
namespace extended {
 
enum class CompareStatus : uint8_t {
  kFarPast, // 0
  kPrior, // 1
  kExactMatch, // 2
  kWithinMatch, // 3
  kFarFuture, // 4
};
 
struct DateTuple {
  DateTuple() = default;
 
  DateTuple(int16_t y, uint8_t mon, uint8_t d, int32_t secs, uint8_t mod)
      : year(y), month(mon), day(d), seconds(secs), suffix(mod)
  {}
 
  int16_t year; // [-1,10000]
  uint8_t month; // [1,12]
  uint8_t day; // [1,31]
  int32_t seconds; // negative values allowed
  uint8_t suffix; // kSuffixS, kSuffixW, kSuffixU
 
  void log() const {
    if (ACE_TIME_EXTENDED_ZONE_PROCESSOR_DEBUG) {
      int16_t minutes = seconds / 60;
      int8_t second = seconds - int32_t(60) * minutes;
      int8_t hour = minutes / 60;
      int8_t minute = minutes - hour * 60;
      char c = "wsu"[(suffix>>4)];
      if (second) {
        logging::printf("%04d-%02u-%02uT%02d:%02d:%02d%c",
            year, month, day, hour, minute, second, c);
      } else {
        logging::printf("%04d-%02u-%02uT%02d:%02d%c",
            year, month, day, hour, minute, c);
      }
    }
  }
};
 
inline bool operator<(const DateTuple& a, const DateTuple& b) {
  if (a.year < b.year) return true;
  if (a.year > b.year) return false;
  if (a.month < b.month) return true;
  if (a.month > b.month) return false;
  if (a.day < b.day) return true;
  if (a.day > b.day) return false;
  if (a.seconds < b.seconds) return true;
  if (a.seconds > b.seconds) return false;
  return false;
}
 
inline bool operator>=(const DateTuple& a, const DateTuple& b) {
  return ! (a < b);
}
 
inline bool operator<=(const DateTuple& a, const DateTuple& b) {
  return ! (b < a);
}
 
inline bool operator>(const DateTuple& a, const DateTuple& b) {
  return (b < a);
}
 
inline bool operator==(const DateTuple& a, const DateTuple& b) {
  return a.year == b.year
      && a.month == b.month
      && a.day == b.day
      && a.seconds == b.seconds
      && a.suffix == b.suffix;
}
 
inline void normalizeDateTuple(DateTuple* dt) {
  const int32_t kOneDayAsSeconds = int32_t(60) * 60 * 24;
  if (dt->seconds <= -kOneDayAsSeconds) {
    LocalDate ld = LocalDate::forComponents(dt->year, dt->month, dt->day);
    local_date_mutation::decrementOneDay(ld);
    dt->year = ld.year();
    dt->month = ld.month();
    dt->day = ld.day();
    dt->seconds += kOneDayAsSeconds;
  } else if (kOneDayAsSeconds <= dt->seconds) {
    LocalDate ld = LocalDate::forComponents(dt->year, dt->month, dt->day);
    local_date_mutation::incrementOneDay(ld);
    dt->year = ld.year();
    dt->month = ld.month();
    dt->day = ld.day();
    dt->seconds -= kOneDayAsSeconds;
  } else {
    // do nothing
  }
}
 
inline void expandDateTuple(
    const DateTuple* tt,
    int32_t offsetSeconds,
    int32_t deltaSeconds,
    DateTuple* ttw,
    DateTuple* tts,
    DateTuple* ttu) {
 
  if (tt->suffix == Info::ZoneContext::kSuffixS) {
    *tts = *tt;
    *ttu = {tt->year, tt->month, tt->day,
        tt->seconds - offsetSeconds,
        Info::ZoneContext::kSuffixU};
    *ttw = {tt->year, tt->month, tt->day,
        tt->seconds + deltaSeconds,
        Info::ZoneContext::kSuffixW};
  } else if (tt->suffix == Info::ZoneContext::kSuffixU) {
    *ttu = *tt;
    *tts = {tt->year, tt->month, tt->day,
        tt->seconds + offsetSeconds,
        Info::ZoneContext::kSuffixS};
    *ttw = {tt->year, tt->month, tt->day,
        tt->seconds + (offsetSeconds + deltaSeconds),
        Info::ZoneContext::kSuffixW};
  } else {
    // Explicit set the suffix to 'w' in case it was something else.
    *ttw = *tt;
    ttw->suffix = Info::ZoneContext::kSuffixW;
    *tts = {tt->year, tt->month, tt->day,
        tt->seconds - deltaSeconds,
        Info::ZoneContext::kSuffixS};
    *ttu = {tt->year, tt->month, tt->day,
        tt->seconds - (deltaSeconds + offsetSeconds),
        Info::ZoneContext::kSuffixU};
  }
 
  normalizeDateTuple(ttw);
  normalizeDateTuple(tts);
  normalizeDateTuple(ttu);
}
 
inline acetime_t subtractDateTuple(const DateTuple& a, const DateTuple& b) {
  int32_t epochDaysA = LocalDate::forComponents(
      a.year, a.month, a.day).toEpochDays();
 
  int32_t epochDaysB = LocalDate::forComponents(
      b.year, b.month, b.day).toEpochDays();
 
  // Perform the subtraction of the days first, before converting to seconds, to
  // prevent overflow if a.year or b.year is more than 68 years from the current
  // epoch year.
  return (epochDaysA - epochDaysB) * 86400 + a.seconds - b.seconds;
}
 
inline CompareStatus compareDateTupleFuzzy(
    const DateTuple& t,
    const DateTuple& start,
    const DateTuple& until) {
  // Use int32_t because a delta year of 2730 or greater will exceed
  // the range of an int16_t.
  int32_t tMonths = t.year * (int32_t) 12 + t.month;
  int32_t startMonths = start.year * (int32_t) 12 + start.month;
  if (tMonths < startMonths - 1) return CompareStatus::kPrior;
  int32_t untilMonths = until.year * 12 + until.month;
  if (untilMonths + 1 < tMonths) return CompareStatus::kFarFuture;
  return CompareStatus::kWithinMatch;
}
 
} // namespace extended
} // namespace ace_time
 
#endif