TimeOffset.h

/*
 * MIT License
 * Copyright (c) 2018 Brian T. Park
 */
 
#ifndef ACE_TIME_TIME_OFFSET_H
#define ACE_TIME_TIME_OFFSET_H
 
#include <stdint.h>
 
class Print;
 
namespace ace_time {
 
// These functions need to set the mSeconds and it seemed inefficient to
// go through the factory method and assignment operator, so I expose
// setMinutes() to them for efficiency.
class TimeOffset;
namespace time_offset_mutation {
void incrementHour(TimeOffset& offset);
void increment15Minutes(TimeOffset& offset);
}
 
class TimeOffset {
  public:
    static TimeOffset forHours(int8_t hours) {
      return TimeOffset::forMinutes(hours * int16_t(60));
    }
 
    static TimeOffset forHourMinute(int8_t hour, int8_t minute) {
      int32_t minutes = (hour * int32_t(60) + minute) * 60;
      return TimeOffset(minutes);
    }
 
    static TimeOffset forHourMinuteSecond(
      int8_t hour, int8_t minute, int8_t second) {
      int32_t seconds = (hour * int32_t(60) + minute) * 60 + second;
      return TimeOffset(seconds);
    }
 
    static TimeOffset forMinutes(int16_t minutes) {
      return TimeOffset(minutes * int32_t(60));
    }
 
    static TimeOffset forSeconds(int32_t seconds) {
      return TimeOffset(seconds);
    }
 
    static TimeOffset forOffsetString(const char* offsetString);
 
    static TimeOffset forOffsetStringChainable(const char*& offsetString);
 
    static TimeOffset forError() { return TimeOffset(kErrorSeconds); }
 
    explicit TimeOffset() {}
 
    int16_t toMinutes() const { return mSeconds / 60; }
 
    int32_t toSeconds() const { return mSeconds; }
 
    void toHourMinute(int8_t& hour, int8_t& minute) const {
      int32_t minutes = mSeconds / 60;
      hour = minutes / 60;
      minute = minutes % 60;
    }
 
    void toHourMinuteSecond(
        int8_t& hour, int8_t& minute, int8_t& second) const {
      int32_t minutes = mSeconds / 60;
      second = mSeconds % 60;
      hour = minutes / 60;
      minute = minutes % 60;
    }
 
    bool isZero() const { return mSeconds == 0; }
 
    bool isError() const {
      return mSeconds == kErrorSeconds;
    }
 
    void printTo(Print& printer) const;
 
    // Use default copy constructor and assignment operator.
    TimeOffset(const TimeOffset&) = default;
    TimeOffset& operator=(const TimeOffset&) = default;
 
  private:
    friend bool operator==(const TimeOffset& a, const TimeOffset& b);
 
    // Give access to setMinutes()
    friend void time_offset_mutation::incrementHour(TimeOffset& offset);
    friend void time_offset_mutation::increment15Minutes(TimeOffset& offset);
 
    explicit TimeOffset(int32_t seconds):
        mSeconds(seconds) {}
 
    void setMinutes(int16_t minutes) {
      mSeconds = minutes * int32_t(60);
    }
 
    void setSeconds(int32_t seconds) {
      mSeconds = seconds;
    }
 
  private:
    static const int32_t kErrorSeconds = INT32_MIN;
 
    int32_t mSeconds = 0;
};
 
inline bool operator==(const TimeOffset& a, const TimeOffset& b) {
  return a.mSeconds == b.mSeconds;
}
 
inline bool operator!=(const TimeOffset& a, const TimeOffset& b) {
  return ! (a == b);
}
 
}
 
#endif