LocalTime.h

/*
 * MIT License
 * Copyright (c) 2018 Brian T. Park
 */
 
#ifndef ACE_TIME_LOCAL_TIME_H
#define ACE_TIME_LOCAL_TIME_H
 
#include <stdint.h>
#include "common/common.h"
 
class Print;
 
namespace ace_time {
 
class LocalTime {
  public:
    static const int32_t kInvalidSeconds = INT32_MIN;
 
    static LocalTime forComponents(uint8_t hour, uint8_t minute,
        uint8_t second, uint8_t fold = 0) {
      return LocalTime(hour, minute, second, fold);
    }
 
    static LocalTime forSeconds(acetime_t seconds, uint8_t fold = 0) {
      uint8_t second, minute, hour;
 
      if (seconds == kInvalidSeconds) {
        second = minute = hour = kInvalidValue; // causes isError() to be true
      } else {
        second = seconds % 60;
        uint16_t minutes = seconds / 60;
        minute = minutes % 60;
        hour = minutes / 60;
      }
 
      // Return a single object to allow return value optimization.
      return LocalTime(hour, minute, second, fold);
    }
 
    static LocalTime forTimeString(const char* timeString);
 
    static LocalTime forTimeStringChainable(const char*& timeString);
 
    static LocalTime forError() {
      return LocalTime(kInvalidValue, kInvalidValue, kInvalidValue);
    }
 
    explicit LocalTime() {}
 
    bool isError() const {
      if (mSecond >= 60) return true;
      if (mMinute >= 60) return true;
      if (mHour == 24) {
        return mSecond != 0 || mMinute != 0;
      }
      return mHour > 24;
    }
 
    uint8_t hour() const { return mHour; }
 
    void hour(uint8_t hour) { mHour = hour; }
 
    uint8_t minute() const { return mMinute; }
 
    void minute(uint8_t minute) { mMinute = minute; }
 
    uint8_t second() const { return mSecond; }
 
    void second(uint8_t second) { mSecond = second; }
 
    uint8_t fold() const { return mFold; }
 
    void fold(uint8_t fold) { mFold = fold; }
 
    acetime_t toSeconds() const {
      if (isError()) {
        return kInvalidSeconds;
      } else {
        return ((mHour * (int16_t) 60) + mMinute)
            * (int32_t) 60 + mSecond;
      }
    }
 
    int8_t compareTo(const LocalTime& that) const {
      if (mHour < that.mHour) return -1;
      if (mHour > that.mHour) return 1;
      if (mMinute < that.mMinute) return -1;
      if (mMinute > that.mMinute) return 1;
      if (mSecond < that.mSecond) return -1;
      if (mSecond > that.mSecond) return 1;
      return 0;
    }
 
    void printTo(Print& printer) const;
 
    // Use default copy constructor and assignment operator.
    LocalTime(const LocalTime&) = default;
    LocalTime& operator=(const LocalTime&) = default;
 
  private:
    friend bool operator==(const LocalTime& a, const LocalTime& b);
 
    static const uint8_t kTimeStringLength = 8;
 
    static const uint8_t kInvalidValue = UINT8_MAX;
 
    explicit LocalTime(
        uint8_t hour,
        uint8_t minute,
        uint8_t second,
        uint8_t fold = 0
    ):
        mHour(hour),
        mMinute(minute),
        mSecond(second),
        mFold(fold)
    {}
 
  private:
    uint8_t mHour; // [0, 23]
    uint8_t mMinute; // [0, 59]
    uint8_t mSecond; // [0, 59]
 
    // Use a separate byte for fold. If we implemented this using a C++ bit
    // field (e.g. the upper bit of 'mHour'), it causes BasicZoneProcessor and
    // ExtendedZoneProcessor to consume 200 extra bytes of flash due to the bit
    // masking operations on accesses and mutations. Even on AVR processors, I
    // think the increase in static memory is better than paying the 200 bytes
    // of flash memory. Using a separate byte is also faster.
    uint8_t mFold; // [0, 1]
};
 
inline bool operator==(const LocalTime& a, const LocalTime& b) {
  return a.mSecond == b.mSecond
      && a.mMinute == b.mMinute
      && a.mHour == b.mHour;
}
 
inline bool operator!=(const LocalTime& a, const LocalTime& b) {
  return ! (a == b);
}
 
}
 
#endif