ZonedDateTime.h

/*
 * MIT License
 * Copyright (c) 2018 Brian T. Park
 */
 
#ifndef ACE_TIME_ZONED_DATE_TIME_H
#define ACE_TIME_ZONED_DATE_TIME_H
 
#include <stdint.h>
#include "OffsetDateTime.h"
#include "TimeZone.h"
 
class Print;
 
namespace ace_time {
 
class ZonedDateTime {
  public:
    static ZonedDateTime forComponents(
        int16_t year, uint8_t month, uint8_t day,
        uint8_t hour, uint8_t minute, uint8_t second,
        const TimeZone& timeZone, uint8_t fold = 0) {
      auto ldt = LocalDateTime::forComponents(
          year, month, day, hour, minute, second, fold);
      return forLocalDateTime(ldt, timeZone);
    }
 
    static ZonedDateTime forLocalDateTime(
        const LocalDateTime& ldt,
        const TimeZone& timeZone) {
      auto odt = timeZone.getOffsetDateTime(ldt);
      return ZonedDateTime(odt, timeZone);
    }
    static ZonedDateTime forEpochSeconds(acetime_t epochSeconds,
        const TimeZone& timeZone) {
      OffsetDateTime odt = (epochSeconds == LocalDate::kInvalidEpochSeconds)
          ? OffsetDateTime::forError()
          : timeZone.getOffsetDateTime(epochSeconds);
      return ZonedDateTime(odt, timeZone);
    }
 
    static ZonedDateTime forUnixSeconds64(
        int64_t unixSeconds, const TimeZone& timeZone) {
      acetime_t epochSeconds;
      if (unixSeconds == LocalDate::kInvalidUnixSeconds64) {
        epochSeconds = LocalDate::kInvalidEpochSeconds;
      } else {
        epochSeconds = unixSeconds
            - Epoch::secondsToCurrentEpochFromUnixEpoch64();
      }
      return forEpochSeconds(epochSeconds, timeZone);
    }
 
    static ZonedDateTime forDateString(const char* dateString) {
      OffsetDateTime dt = OffsetDateTime::forDateString(dateString);
      return ZonedDateTime(dt, TimeZone::forTimeOffset(dt.timeOffset()));
    }
 
    static ZonedDateTime forDateString(const __FlashStringHelper* dateString) {
      OffsetDateTime dt = OffsetDateTime::forDateString(dateString);
      return ZonedDateTime(dt, TimeZone::forTimeOffset(dt.timeOffset()));
    }
 
    static ZonedDateTime forError() {
      return ZonedDateTime(OffsetDateTime::forError(), TimeZone());
    }
 
    explicit ZonedDateTime() {}
 
    bool isError() const { return mOffsetDateTime.isError(); }
 
    int16_t year() const { return mOffsetDateTime.year(); }
 
    void year(int16_t year) { mOffsetDateTime.year(year); }
 
    uint8_t month() const { return mOffsetDateTime.month(); }
 
    void month(uint8_t month) { mOffsetDateTime.month(month); }
 
    uint8_t day() const { return mOffsetDateTime.day(); }
 
    void day(uint8_t day) { mOffsetDateTime.day(day); }
 
    uint8_t hour() const { return mOffsetDateTime.hour(); }
 
    void hour(uint8_t hour) { mOffsetDateTime.hour(hour); }
 
    uint8_t minute() const { return mOffsetDateTime.minute(); }
 
    void minute(uint8_t minute) { mOffsetDateTime.minute(minute); }
 
    uint8_t second() const { return mOffsetDateTime.second(); }
 
    void second(uint8_t second) { mOffsetDateTime.second(second); }
 
    uint8_t fold() const { return mOffsetDateTime.fold(); }
 
    void fold(uint8_t fold) { mOffsetDateTime.fold(fold); }
 
    uint8_t dayOfWeek() const { return mOffsetDateTime.dayOfWeek(); }
 
    const TimeZone& timeZone() const { return mTimeZone; }
 
    void timeZone(const TimeZone& timeZone) { mTimeZone = timeZone; }
 
    TimeOffset timeOffset() const { return mOffsetDateTime.timeOffset(); }
 
    const LocalDateTime& localDateTime() const {
      return mOffsetDateTime.localDateTime();
    }
 
    const OffsetDateTime& offsetDateTime() const {
      return mOffsetDateTime;
    }
 
    void normalize() {
      mOffsetDateTime = mTimeZone.getOffsetDateTime(localDateTime());
    }
 
    ZonedDateTime convertToTimeZone(const TimeZone& timeZone) const {
      acetime_t epochSeconds = toEpochSeconds();
      return ZonedDateTime::forEpochSeconds(epochSeconds, timeZone);
    }
 
    int32_t toEpochDays() const {
      return mOffsetDateTime.toEpochDays();
    }
 
    int32_t toUnixDays() const {
      return mOffsetDateTime.toUnixDays();
    }
 
    acetime_t toEpochSeconds() const {
      return mOffsetDateTime.toEpochSeconds();
    }
 
    int64_t toUnixSeconds64() const {
      return mOffsetDateTime.toUnixSeconds64();
    }
 
    int8_t compareTo(const ZonedDateTime& that) const {
      return mOffsetDateTime.compareTo(that.mOffsetDateTime);
    }
 
    void printTo(Print& printer) const;
 
    // Use default copy constructor and assignment operator.
    ZonedDateTime(const ZonedDateTime&) = default;
    ZonedDateTime& operator=(const ZonedDateTime&) = default;
 
  private:
    static const uint8_t kDateStringLength = 25;
 
    friend bool operator==(const ZonedDateTime& a, const ZonedDateTime& b);
 
    ZonedDateTime(const OffsetDateTime& offsetDateTime, const TimeZone& tz):
      mOffsetDateTime(offsetDateTime),
      mTimeZone(tz) {}
 
    OffsetDateTime mOffsetDateTime;
    TimeZone mTimeZone;
};
 
inline bool operator==(const ZonedDateTime& a, const ZonedDateTime& b) {
  return a.mOffsetDateTime == b.mOffsetDateTime
      && a.mTimeZone == b.mTimeZone;
}
 
inline bool operator!=(const ZonedDateTime& a, const ZonedDateTime& b) {
  return ! (a == b);
}
 
}
 
#endif