OffsetDateTime.h

/*
 * MIT License
 * Copyright (c) 2018 Brian T. Park
 */
 
#ifndef ACE_TIME_OFFSET_DATE_TIME_H
#define ACE_TIME_OFFSET_DATE_TIME_H
 
#include <stdint.h>
#include "TimeOffset.h"
#include "LocalDateTime.h"
 
class Print;
 
namespace ace_time {
 
class OffsetDateTime {
  public:
 
    static OffsetDateTime forLocalDateTimeAndOffset(
        const LocalDateTime& localDateTime, TimeOffset timeOffset) {
      return OffsetDateTime(localDateTime, timeOffset);
    }
 
    static OffsetDateTime forComponents(int16_t year, uint8_t month,
        uint8_t day, uint8_t hour, uint8_t minute, uint8_t second,
        TimeOffset timeOffset, uint8_t fold = 0) {
      auto ldt = LocalDateTime::forComponents(
          year, month, day, hour, minute, second, fold);
      return OffsetDateTime(ldt, timeOffset);
    }
 
    static OffsetDateTime forEpochSeconds(acetime_t epochSeconds,
          TimeOffset timeOffset, uint8_t fold = 0) {
      if (epochSeconds != LocalDate::kInvalidEpochSeconds) {
        epochSeconds += timeOffset.toSeconds();
      }
      auto ldt = LocalDateTime::forEpochSeconds(epochSeconds, fold);
      return OffsetDateTime(ldt, timeOffset);
    }
 
    static OffsetDateTime forUnixSeconds64(
        int64_t unixSeconds, TimeOffset timeOffset, int8_t fold = 0) {
      if (unixSeconds != LocalDate::kInvalidUnixSeconds64) {
        unixSeconds += timeOffset.toSeconds();
      }
      auto ldt = LocalDateTime::forUnixSeconds64(unixSeconds, fold);
      return OffsetDateTime(ldt, timeOffset);
    }
 
    static OffsetDateTime forDateString(const char* dateString);
 
    static OffsetDateTime forDateString(const __FlashStringHelper* dateString);
 
    static OffsetDateTime forDateStringChainable(const char*& dateString);
 
    static OffsetDateTime forError() {
      return OffsetDateTime(LocalDateTime::forError(), TimeOffset::forError());
    }
 
    explicit OffsetDateTime() {}
 
    bool isError() const {
      // Check mTimeOffset first because it's expected to be invalid more often.
      return  mTimeOffset.isError() || mLocalDateTime.isError();
    }
 
    int16_t year() const { return mLocalDateTime.year(); }
 
    void year(int16_t year) { mLocalDateTime.year(year); }
 
    uint8_t month() const { return mLocalDateTime.month(); }
 
    void month(uint8_t month) { mLocalDateTime.month(month); }
 
    uint8_t day() const { return mLocalDateTime.day(); }
 
    void day(uint8_t day) { mLocalDateTime.day(day); }
 
    uint8_t hour() const { return mLocalDateTime.hour(); }
 
    void hour(uint8_t hour) { mLocalDateTime.hour(hour); }
 
    uint8_t minute() const { return mLocalDateTime.minute(); }
 
    void minute(uint8_t minute) { mLocalDateTime.minute(minute); }
 
    uint8_t second() const { return mLocalDateTime.second(); }
 
    void second(uint8_t second) { mLocalDateTime.second(second); }
 
    uint8_t fold() const { return mLocalDateTime.fold(); }
 
    void fold(uint8_t fold) { mLocalDateTime.fold(fold); }
 
    uint8_t dayOfWeek() const { return mLocalDateTime.dayOfWeek(); }
 
    TimeOffset timeOffset() const { return mTimeOffset; }
 
    void timeOffset(TimeOffset timeOffset) { mTimeOffset = timeOffset; }
 
    const LocalDateTime& localDateTime() const { return mLocalDateTime; }
 
    const LocalDate& localDate() const { return mLocalDateTime.localDate(); }
 
    const LocalTime& localTime() const { return mLocalDateTime.localTime(); }
 
    OffsetDateTime convertToTimeOffset(TimeOffset timeOffset) const {
      acetime_t epochSeconds = toEpochSeconds();
      return OffsetDateTime::forEpochSeconds(epochSeconds, timeOffset);
    }
 
    int32_t toEpochDays() const {
      if (isError()) return LocalDate::kInvalidEpochDays;
 
      int32_t epochDays = mLocalDateTime.localDate().toEpochDays();
 
      // Increment or decrement the day count depending on the time offset.
      acetime_t timeOffset = mLocalDateTime.localTime().toSeconds()
          - mTimeOffset.toSeconds();
      if (timeOffset >= 86400) {
        epochDays++;
      } else if (timeOffset < 0) {
        epochDays--;
      }
 
      return epochDays;
    }
 
    int32_t toUnixDays() const {
      if (isError()) return LocalDate::kInvalidEpochDays;
      return toEpochDays() + Epoch::daysToCurrentEpochFromUnixEpoch();
    }
 
    acetime_t toEpochSeconds() const {
      if (isError()) return LocalDate::kInvalidEpochSeconds;
      acetime_t epochSeconds = mLocalDateTime.toEpochSeconds();
      if (epochSeconds == LocalDate::kInvalidEpochSeconds) {
        return epochSeconds;
      }
      return epochSeconds - mTimeOffset.toSeconds();
    }
 
    int64_t toUnixSeconds64() const {
      if (isError()) return LocalDate::kInvalidUnixSeconds64;
      return mLocalDateTime.toUnixSeconds64() - mTimeOffset.toSeconds();
    }
 
    int8_t compareTo(const OffsetDateTime& that) const {
      acetime_t thisSeconds = toEpochSeconds();
      acetime_t thatSeconds = that.toEpochSeconds();
      if (thisSeconds < thatSeconds) return -1;
      if (thisSeconds > thatSeconds) return 1;
      return 0;
    }
 
    void printTo(Print& printer) const;
 
    // Use default copy constructor and assignment operator.
    OffsetDateTime(const OffsetDateTime&) = default;
    OffsetDateTime& operator=(const OffsetDateTime&) = default;
 
  private:
    friend bool operator==(const OffsetDateTime& a, const OffsetDateTime& b);
 
    static const uint8_t kDateStringLength = 25;
 
    explicit OffsetDateTime(const LocalDateTime& ldt, TimeOffset timeOffset):
        mLocalDateTime(ldt),
        mTimeOffset(timeOffset) {}
 
    LocalDateTime mLocalDateTime;
    TimeOffset mTimeOffset;
};
 
inline bool operator==(const OffsetDateTime& a, const OffsetDateTime& b) {
  return a.mLocalDateTime == b.mLocalDateTime
      && a.mTimeOffset == b.mTimeOffset;
}
 
inline bool operator!=(const OffsetDateTime& a, const OffsetDateTime& b) {
  return ! (a == b);
}
 
}
 
#endif