time.hpp

Go to the documentation of this file.

#pragma once
 
#include "ffi_core.hpp"
 
namespace tempoch {
 
// ============================================================================
// UTC
// ============================================================================
 
struct UTC {
    int32_t  year;
    uint8_t  month;
    uint8_t  day;
    uint8_t  hour;
    uint8_t  minute;
    uint8_t  second;
    uint32_t nanosecond;
 
    UTC() : year(2000), month(1), day(1), hour(12), minute(0), second(0), nanosecond(0) {}
 
    UTC(int32_t y, uint8_t mo, uint8_t d,
        uint8_t h = 0, uint8_t mi = 0, uint8_t s = 0, uint32_t ns = 0)
        : year(y), month(mo), day(d), hour(h), minute(mi), second(s), nanosecond(ns) {}
 
    tempoch_utc_t to_c() const {
        return {year, month, day, hour, minute, second, nanosecond};
    }
 
    static UTC from_c(const tempoch_utc_t& c) {
        return UTC(c.year, c.month, c.day, c.hour, c.minute, c.second, c.nanosecond);
    }
};
 
// ============================================================================
// JulianDate
// ============================================================================
 
class JulianDate {
    double m_value;
 
public:
    constexpr explicit JulianDate(double v) : m_value(v) {}
 
    static JulianDate J2000() { return JulianDate(tempoch_jd_j2000()); }
 
    static JulianDate from_utc(const UTC& utc) {
        double jd;
        auto c = utc.to_c();
        check_status(tempoch_jd_from_utc(c, &jd), "JulianDate::from_utc");
        return JulianDate(jd);
    }
 
    constexpr double value() const { return m_value; }
 
    double to_mjd() const { return tempoch_jd_to_mjd(m_value); }
 
    UTC to_utc() const {
        tempoch_utc_t out;
        check_status(tempoch_jd_to_utc(m_value, &out), "JulianDate::to_utc");
        return UTC::from_c(out);
    }
 
    double operator-(const JulianDate& other) const {
        return tempoch_jd_difference(m_value, other.m_value);
    }
 
    JulianDate operator+(double days) const {
        return JulianDate(tempoch_jd_add_days(m_value, days));
    }
 
    double julian_centuries() const {
        return tempoch_jd_julian_centuries(m_value);
    }
 
    bool operator==(const JulianDate& o) const { return m_value == o.m_value; }
    bool operator!=(const JulianDate& o) const { return m_value != o.m_value; }
    bool operator< (const JulianDate& o) const { return m_value <  o.m_value; }
    bool operator<=(const JulianDate& o) const { return m_value <= o.m_value; }
    bool operator> (const JulianDate& o) const { return m_value >  o.m_value; }
    bool operator>=(const JulianDate& o) const { return m_value >= o.m_value; }
};
 
// ============================================================================
// MJD (Modified Julian Date)
// ============================================================================
 
class MJD {
    double m_value;
 
public:
    constexpr MJD() : m_value(0.0) {}
    constexpr explicit MJD(double v) : m_value(v) {}
 
    static MJD from_utc(const UTC& utc) {
        double mjd;
        auto c = utc.to_c();
        check_status(tempoch_mjd_from_utc(c, &mjd), "MJD::from_utc");
        return MJD(mjd);
    }
 
    static MJD from_jd(const JulianDate& jd) {
        return MJD(tempoch_jd_to_mjd(jd.value()));
    }
 
    constexpr double value() const { return m_value; }
 
    JulianDate to_jd() const { return JulianDate(tempoch_mjd_to_jd(m_value)); }
 
    UTC to_utc() const {
        tempoch_utc_t out;
        check_status(tempoch_mjd_to_utc(m_value, &out), "MJD::to_utc");
        return UTC::from_c(out);
    }
 
    double operator-(const MJD& other) const {
        return tempoch_mjd_difference(m_value, other.m_value);
    }
 
    MJD operator+(double days) const {
        return MJD(tempoch_mjd_add_days(m_value, days));
    }
 
    bool operator==(const MJD& o) const { return m_value == o.m_value; }
    bool operator!=(const MJD& o) const { return m_value != o.m_value; }
    bool operator< (const MJD& o) const { return m_value <  o.m_value; }
    bool operator<=(const MJD& o) const { return m_value <= o.m_value; }
    bool operator> (const MJD& o) const { return m_value >  o.m_value; }
    bool operator>=(const MJD& o) const { return m_value >= o.m_value; }
};
 
} // namespace tempoch