TimePeriod.h

/*
 * MIT License
 * Copyright (c) 2018 Brian T. Park
 */
 
#ifndef ACE_TIME_TIME_PERIOD_H
#define ACE_TIME_TIME_PERIOD_H
 
#include <stdint.h>
 
class Print;
 
namespace ace_time {
 
class TimePeriod {
  public:
    static const int32_t kInvalidPeriodSeconds = INT32_MIN;
 
    static const int32_t kMaxPeriodSeconds = 921599;
 
    static TimePeriod forError(int8_t sign = 0) {
      return TimePeriod(255, 255, 255, sign);
    }
 
    explicit TimePeriod(uint8_t hour, uint8_t minute, uint8_t second,
            int8_t sign = 1):
        mHour(hour),
        mMinute(minute),
        mSecond(second),
        mSign(sign) {}
 
    explicit TimePeriod(int32_t seconds = 0) {
      if (seconds == kInvalidPeriodSeconds) {
        mHour = mMinute = mSecond = 255;
        mSign = 0;
        return;
      } else if (seconds < -kMaxPeriodSeconds) {
        mHour = mMinute = mSecond = 255;
        mSign = -1;
        return;
      } else if (seconds > kMaxPeriodSeconds) {
        mHour = mMinute = mSecond = 255;
        mSign = 1;
        return;
      }
 
      if (seconds < 0) {
        mSign = -1;
        seconds = -seconds;
      } else {
        mSign = 1;
      }
      mSecond = seconds % 60;
      seconds /= 60;
      mMinute = seconds % 60;
      seconds /= 60;
      mHour = seconds;
    }
 
    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; }
 
    int8_t sign() const { return mSign; }
 
    void sign(int8_t sign) { mSign = sign; }
 
    int32_t toSeconds() const {
      if (isError()) {
        return kInvalidPeriodSeconds;
      }
      int32_t seconds = ((mHour * (int16_t) 60) + mMinute) * (int32_t) 60
          + mSecond;
      return (mSign > 0) ? seconds : -seconds;
    }
 
    bool isError() const {
      return mSign == 0 || mSecond == 255 || mMinute == 255;
    }
 
    int8_t compareTo(const TimePeriod& that) const {
      int32_t thisSeconds = toSeconds();
      int32_t thatSeconds = that.toSeconds();
      if (thisSeconds < thatSeconds) {
        return -1;
      } else if (thisSeconds > thatSeconds) {
        return 1;
      } else {
        return 0;
      }
    }
 
    void printTo(Print& printer) const;
 
    // Use default copy constructor and assignment operator.
    TimePeriod(const TimePeriod&) = default;
    TimePeriod& operator=(const TimePeriod&) = default;
 
  private:
    friend bool operator==(const TimePeriod& a, const TimePeriod& b);
 
    uint8_t mHour; // [0, 255], normally hour < 24
    uint8_t mMinute; // [0, 59], normally minute < 60
    uint8_t mSecond; // [0, 59], normally second < 60
 
    int8_t mSign;
};
 
inline bool operator==(const TimePeriod& a, const TimePeriod& b) {
  return a.mSecond == b.mSecond
      && a.mMinute == b.mMinute
      && a.mHour == b.mHour
      && a.mSign == b.mSign;
}
 
inline bool operator!=(const TimePeriod& a, const TimePeriod& b) {
  return ! (a == b);
}
 
}
 
#endif