datetime.h

Go to the documentation of this file.

#ifndef ION_BASE_DATETIME_H_
#define ION_BASE_DATETIME_H_

#include <chrono>  // NOLINT
#include <cmath>
#include <sstream>
#include <string>
#include <type_traits>

#include "base/integral_types.h"
#include "ion/base/referent.h"
#include "ion/external/gtest/gunit_prod.h"  // For FRIEND_TEST().

namespace ion {
namespace base {

class DateTime {
 public:
  enum DateTimeField {
    kYear = 0,
    kMonth = 1,
    kDay = 2,
    kHour = 3,
    kMinute = 4,
    kSecond = 5,
    kNanosecond = 6,
    kNumFields
  };

  class Range {
   public:
    Range() {
      begin_.reset(new DateTime);
      end_.reset(new DateTime);
    }
    Range(const Range& rhs) {
      *begin_ = rhs.begin();
      *end_ = rhs.end();
    }
    ~Range() {}

    const DateTime& begin() const { return *begin_; }
    const DateTime& end() const { return *end_; }

    void SetBegin(const DateTime& begin) { *begin_ = begin; }
    void SetEnd(const DateTime& end) { *end_ = end; }

    void SetInterpolation(const Range& begin,
        const Range& end,
        float t) {
      *begin_ = DateTime::Interpolate(begin.begin(), end.begin(), t);
      *end_ = DateTime::Interpolate(begin.end(), end.end(), t);
    }

    static Range Interpolate(const Range& begin,
        const Range& end,
        float t) {
      Range interpolated;
      interpolated.SetInterpolation(begin, end, t);
      return interpolated;
    }

   private:
    std::unique_ptr<DateTime> begin_;
    std::unique_ptr<DateTime> end_;
  };

  DateTime();
  DateTime(const DateTime& rhs);

  DateTime(int64 year, uint8 month, uint8 day, uint8 hour, uint8 minute,
           uint8 second, uint32 nanosec = 0, int8 zone_hours = 0,
           int8 zone_minutes = 0);

  explicit DateTime(std::chrono::system_clock::time_point time,
                    int8 zone_hours = 0, int8 zone_minutes = 0);

  template <typename Rep>
  static DateTime CreateFromPosixSeconds(Rep secs, int8 zone_hours = 0,
                                         int8 zone_minutes = 0) {
    DateTime date;
    date.Reset();
    if (std::is_integral<Rep>::value) {
      date.SetFromPosixSecondsOnly(static_cast<int64>(secs), zone_hours,
                                   zone_minutes);
    } else {
      secs += static_cast<Rep>(0.5e-9);
      const Rep seconds = static_cast<Rep>(std::floor(secs));
      const Rep nanoseconds = static_cast<Rep>(1e9) * (secs - seconds);
      date.SetFromPosixSecondsOnly(static_cast<int64>(seconds), zone_hours,
                                   zone_minutes);
      date.nanosecond_ = static_cast<uint32>(nanoseconds);
    }
    return date;
  }

  virtual ~DateTime() {}

  int64 GetYear() const { return year_; }
  uint8 GetMonth() const { return month_; }
  uint8 GetDay() const { return day_; }
  uint8 GetHour() const { return hour_; }
  uint8 GetMinute() const { return minute_; }
  uint8 GetSecond() const { return second_; }
  uint32 GetNanosecond() const { return nanosecond_; }
  int8 GetZoneHours() const { return zone_hours_; }
  int8 GetZoneMinutes() const { return zone_minutes_; }

  void SetYear(int64 year);
  void SetMonth(uint8 month);
  void SetDay(uint8 day);
  void SetHour(uint8 hour);
  void SetMinute(uint8 minute);
  void SetSecond(uint8 second);
  void SetNanosecond(uint32 nanosecond);
  void SetZoneHours(int8 zone_hours);
  void SetZoneMinutes(int8 zone_minutes);

  void Reset();

  void Set(int64 years,
           uint8 months,
           uint8 days,
           uint8 hours,
           uint8 minutes,
           uint8 seconds,
           int8 zone_hours,
           int8 zone_minutes);

  void Set(int64 years,
           uint8 months,
           uint8 days,
           uint8 hours,
           uint8 minutes,
           uint8 seconds,
           uint32 nanoseconds,
           int8 zone_hours,
           int8 zone_minutes);

  void Set(const DateTime& other);

  void Normalize() { AdjustTimeZone(0, 0); }

  bool IsEqualByComponent(const DateTime& dtime) const;

  bool operator==(const DateTime& dtime) const;

  bool operator>(const DateTime& dtime) const;
  bool operator<(const DateTime& dtime) const { return dtime > *this; }
  bool operator>=(const DateTime& dtime) const { return !(*this < dtime); }
  bool operator<=(const DateTime& dtime) const { return !(*this > dtime); }
  bool operator!=(const DateTime& dtime) const { return !(*this == dtime); }
  DateTime& operator=(const DateTime& rhs);

  std::chrono::system_clock::time_point GetTimePoint() const;

  template <typename Rep = double>
  Rep GetPosixSeconds() const {
    const int64 posix_seconds = GetPosixSecondsOnly();
    return static_cast<Rep>(posix_seconds) +
           static_cast<Rep>(1e-9) * nanosecond_;
  }

  void Lerp(const DateTime& origin, const DateTime& target, double t);

  void AdjustTimeZone(int newHours, int newMins);

  std::string ToString() const;

  bool FromString(const std::string& str);

  enum DateStringEnum {
    kRenderDayMonthYear = 1,
    kRenderMonthYear,
    kRenderYearOnly
  };
  enum TimeStringEnum {
    kRenderHoursMinutesSeconds = 1,
    kRenderHoursMinutes,
    kRenderHoursOnly
  };
  void ComputeDateString(const DateStringEnum output_date_format,
                         std::string* out_string) const;
  void ComputeTimeString(const TimeStringEnum output_time_format,
                         std::string* out_string) const;

  std::string ComputeDurationString(double fractional_seconds) const;

  double GetJulianDate() const;

  double GetTimeAsDecimal() const;

  double GetJ2000Date() const {
    static const double kJulianDate2000 = 2451545.0;
    double julian_date = GetJulianDate();
    return julian_date - kJulianDate2000;
  }

  bool IsUndefined() const { return year_ == kUndefinedYear; }

  void MakeUndefined() { year_ = kUndefinedYear; }

  void operator+=(int64 secs) {
    uint32 nanoseconds = nanosecond_;
    SetFromPosixSecondsOnly(GetPosixSecondsOnly() + secs, zone_hours_,
                            zone_minutes_);
    nanosecond_ = nanoseconds;
  }
  void operator-=(int64 secs) { *this += -secs; }

  void operator+=(int secs) { *this += static_cast<int64>(secs); }
  void operator+=(double secs);
  void operator-=(int secs) { *this += -secs; }
  void operator-=(double secs) { *this += -secs; }

  static DateTime Interpolate(const DateTime& begin,
                              const DateTime& end,
                              double t);

  static double GetDurationSecs(const DateTime& begin, const DateTime& end);

  static double GetInterpValue(const DateTime& now,
                               const DateTime& time_a,
                               const DateTime& time_b);

  static bool ParseYMString(const std::string& date, DateTime* date_out);

  int64 GetDateTimeField(DateTimeField field) const;

  int64 GetDateTimeField(uint8 field) const {
    DCHECK(field < static_cast<uint8>(kNumFields));
    return GetDateTimeField(static_cast<DateTimeField>(field));
  }

 protected:
  virtual bool Use24HourTime() const;

 private:
  void SetFromPosixSecondsOnly(int64 secs, int8 requested_zone_hours,
                               int8 requested_zone_minutes);

  int64 GetPosixSecondsOnly() const;

  static const int64 kUndefinedYear = kint64max;

  int64 year_;
  uint8 month_;
  uint8 day_;
  uint8 hour_;  // Always a 24-hour representation internally.
  uint8 minute_;
  uint8 second_;
  uint32 nanosecond_;
  int8 zone_hours_;
  int8 zone_minutes_;

  FRIEND_TEST(DateTime, Use24HourTime);
  FRIEND_TEST(DateTime, NewestOldestDateTime);
};

std::ostream& operator<<(std::ostream& os, const DateTime& dtime);
std::istream& operator>>(std::istream& in, DateTime& dtime);

}  // namespace base
}  // namespace ion

#endif  // ION_BASE_DATETIME_H_