LocalDateTime.h

/*
 * MIT License
 * Copyright (c) 2018 Brian T. Park
 */
 
#ifndef ACE_TIME_LOCAL_DATE_TIME_H
#define ACE_TIME_LOCAL_DATE_TIME_H
 
#include <stddef.h> // size_t
#include <stdint.h> // uint8_t, etc
#include <string.h> // strlen()
#include "LocalDate.h"
#include "LocalTime.h"
 
class Print;
class __FlashStringHelper;
 
namespace ace_time {
 
class LocalDateTime {
  public:
 
    static LocalDateTime forComponents(int16_t year, uint8_t month,
        uint8_t day, uint8_t hour, uint8_t minute, uint8_t second,
        uint8_t fold = 0) {
      LocalDate ld = LocalDate::forComponents(year, month, day);
      LocalTime lt = LocalTime::forComponents(hour, minute, second, fold);
      return LocalDateTime(ld, lt);
    }
 
    static LocalDateTime forEpochSeconds(
        acetime_t epochSeconds, uint8_t fold = 0) {
      if (epochSeconds == LocalDate::kInvalidEpochSeconds) {
        return forError();
      }
 
      // Integer floor-division towards -infinity
      int32_t days = (epochSeconds < 0)
          ? (epochSeconds + 1) / 86400 - 1
          : epochSeconds / 86400;
 
      // Avoid % operator, because it's slow on an 8-bit process and because
      // epochSeconds could be negative.
      int32_t seconds = epochSeconds - 86400 * days;
 
      LocalDate ld = LocalDate::forEpochDays(days);
      LocalTime lt = LocalTime::forSeconds(seconds, fold);
      return LocalDateTime(ld, lt);
    }
 
    static LocalDateTime forUnixSeconds64(
        int64_t unixSeconds, uint8_t fold = 0) {
      if (unixSeconds == LocalDate::kInvalidUnixSeconds64) {
        return forError();
      }
 
      int64_t epochSeconds64 = unixSeconds
          - Epoch::secondsToCurrentEpochFromUnixEpoch64();
 
      // Integer floor-division towards -infinity
      int32_t days = (epochSeconds64 < 0)
          ? (epochSeconds64 + 1) / 86400 - 1
          : epochSeconds64 / 86400;
      int32_t seconds = epochSeconds64 - (int64_t) 86400 * days;
 
      LocalDate ld = LocalDate::forEpochDays(days);
      LocalTime lt = LocalTime::forSeconds(seconds, fold);
      return LocalDateTime(ld, lt);
    }
 
    static LocalDateTime forDateString(const char* dateString);
 
    static LocalDateTime forDateString(const __FlashStringHelper* dateString);
 
    static LocalDateTime forDateStringChainable(const char*& dateString);
 
    static LocalDateTime forError() {
      return LocalDateTime(LocalDate::forError(), LocalTime::forError());
    }
 
    explicit LocalDateTime() {}
 
    bool isError() const {
      return mLocalDate.isError() || mLocalTime.isError();
    }
 
    int16_t year() const { return mLocalDate.year(); }
 
    void year(int16_t year) { mLocalDate.year(year); }
 
    uint8_t month() const { return mLocalDate.month(); }
 
    void month(uint8_t month) { mLocalDate.month(month); }
 
    uint8_t day() const { return mLocalDate.day(); }
 
    void day(uint8_t day) { mLocalDate.day(day); }
 
    uint8_t hour() const { return mLocalTime.hour(); }
 
    void hour(uint8_t hour) { mLocalTime.hour(hour); }
 
    uint8_t minute() const { return mLocalTime.minute(); }
 
    void minute(uint8_t minute) { mLocalTime.minute(minute); }
 
    uint8_t second() const { return mLocalTime.second(); }
 
    void second(uint8_t second) { mLocalTime.second(second); }
 
    uint8_t fold() const { return mLocalTime.fold(); }
 
    void fold(uint8_t fold) { mLocalTime.fold(fold); }
 
    uint8_t dayOfWeek() const { return mLocalDate.dayOfWeek(); }
 
    const LocalDate& localDate() const { return mLocalDate; }
 
    const LocalTime& localTime() const { return mLocalTime; }
 
    int32_t toEpochDays() const {
      if (isError()) return LocalDate::kInvalidEpochDays;
      return mLocalDate.toEpochDays();
    }
 
    int32_t toUnixDays() const {
      if (isError()) return LocalDate::kInvalidEpochDays;
      return toEpochDays() + Epoch::daysToCurrentEpochFromUnixEpoch();
    }
 
    acetime_t toEpochSeconds() const {
      if (isError()) return LocalDate::kInvalidEpochSeconds;
      int32_t days = mLocalDate.toEpochDays();
      int32_t seconds = mLocalTime.toSeconds();
      return (int32_t) 86400 * days + seconds;
    }
 
    int64_t toUnixSeconds64() const {
      if (isError()) return LocalDate::kInvalidUnixSeconds64;
      int32_t days = toUnixDays();
      int32_t seconds = mLocalTime.toSeconds();
      return (int64_t) 86400 * days + seconds;
    }
 
    int8_t compareTo(const LocalDateTime& that) const {
      int8_t dateCompare = localDate().compareTo(that.localDate());
      if (dateCompare != 0) return dateCompare;
      int8_t timeCompare = localTime().compareTo(that.localTime());
      if (timeCompare != 0) return timeCompare;
      return 0;
    }
 
    void printTo(Print& printer) const;
 
    // Use default copy constructor and assignment operator.
    LocalDateTime(const LocalDateTime&) = default;
    LocalDateTime& operator=(const LocalDateTime&) = default;
 
  private:
    friend bool operator==(const LocalDateTime& a, const LocalDateTime& b);
 
    static const uint8_t kDateTimeStringLength = 19;
 
    explicit LocalDateTime(const LocalDate& ld, const LocalTime& lt):
        mLocalDate(ld),
        mLocalTime(lt) {}
 
    LocalDate mLocalDate;
    LocalTime mLocalTime;
};
 
inline bool operator==(const LocalDateTime& a, const LocalDateTime& b) {
  return a.mLocalDate == b.mLocalDate
      && a.mLocalTime == b.mLocalTime;
}
 
inline bool operator!=(const LocalDateTime& a, const LocalDateTime& b) {
  return ! (a == b);
}
 
}
 
#endif