DateTime.hpp

 
 
#pragma once
 
#include "AstUtil/StringView.hpp"
#include "AstGlobal.h"
#include "Date.hpp"
#include "Time.hpp"
#include <time.h>
#include <string>
 
 
struct tm;
 
AST_NAMESPACE_BEGIN
 
 
constexpr int kTimeDefaultFormatPrecision = 3;
 
class DateTime;
 
AST_CORE_CAPI void aCurrentDateTimeLocal(DateTime& dttm);
 
AST_CORE_CAPI void aCurrentDateTimeUTC(DateTime& dttm);
 
AST_CORE_CAPI void aTodayDateTimeUTC(DateTime& dttm);
 
AST_CORE_CAPI void aTomorrowDateTimeUTC(DateTime& dttm);
 
// --------------------
// 日期时间规范化
// --------------------
 
AST_CORE_CAPI void aDateTimeNormalize(DateTime& dttm);
 
AST_CORE_CAPI void aDateTimeNormalizeUTC(DateTime& dttm);
 
AST_CORE_CAPI void aDateTimeNormalizeLocal(DateTime& dttm, int timezone);
 
AST_CORE_CAPI void aDateTimeNormalizeBJT(DateTime& dttm);
 
 
 
// -------------
// 日期时间递增
// -------------
 
 
AST_CORE_CAPI void aDateTimeAddYears(DateTime& dttm, int years);
 
AST_CORE_CAPI void aDateTimeAddMonths(DateTime& dttm, int months);
 
AST_CORE_CAPI void aDateTimeAddDays(DateTime& dttm, int days);
 
 
AST_CORE_CAPI void aDateTimeAddDaysUTC(DateTime& dttm, int days);
 
 
AST_CORE_CAPI void aDateTimeAddDaysLocal(DateTime& dttm, int days, int timezone);
 
 
AST_CORE_CAPI void aDateTimeAddDaysBJT(DateTime& dttm, int days);
 
 
 
AST_CORE_CAPI void aDateTimeAddHours(DateTime& dttm, int hours);
 
 
AST_CORE_CAPI void aDateTimeAddHoursUTC(DateTime& dttm, int hours);
 
AST_CORE_CAPI void aDateTimeAddHoursLocal(DateTime& dttm, int hours, int timezone);
 
 
AST_CORE_CAPI void aDateTimeAddHoursBJT(DateTime& dttm, int hours);
 
 
AST_CORE_CAPI void aDateTimeAddMinutes(DateTime& dttm, int minutes);
 
 
AST_CORE_CAPI void aDateTimeAddMinutesUTC(DateTime& dttm, int minutes);
 
 
 
AST_CORE_CAPI void aDateTimeAddMinutesLocal(DateTime& dttm, int minutes, int timezone);
 
 
AST_CORE_CAPI void aDateTimeAddMinutesBJT(DateTime& dttm, int minutes);
 
 
AST_CORE_CAPI void aDateTimeAddSeconds(DateTime& dttm, double seconds);
 
 
AST_CORE_CAPI void aDateTimeAddSecondsUTC(DateTime& dttm, double seconds);
 
 
AST_CORE_CAPI void aDateTimeAddSecondsLocal(DateTime& dttm, double seconds, int timezone);
 
 
AST_CORE_CAPI void aDateTimeAddSecondsBJT(DateTime& dttm, double seconds);
 
 
 
// -------------
// 日期时间格式化
// -------------
 
 
AST_CORE_CAPI errc_t aDateTimeFormat(const DateTime& dttm, StringView format, std::string& str);
 
 
AST_CORE_CAPI errc_t aDateTimeFormatGregorian(const DateTime& dttm, std::string& str, int precision = kTimeDefaultFormatPrecision);
 
 
AST_CORE_CAPI errc_t aDateTimeFormatGregorianEn(const DateTime& dttm, std::string& str, int precision = kTimeDefaultFormatPrecision);
 
 
AST_CORE_CAPI errc_t aDateTimeFormatGMT(const DateTime& dttm, std::string& str);
 
 
AST_CORE_CAPI errc_t aDateTimeFormatISO8601(const DateTime& dttm, std::string& str);
 
 
A_ALWAYS_INLINE errc_t aDateTimeFormatISO(const DateTime& dttm, std::string& str)
{
    return aDateTimeFormatISO8601(dttm, str);
}
 
 
 
AST_CORE_CAPI errc_t aDateTimeFormatRFC3339(const DateTime& dttm, std::string& str);
 
 
#ifdef AST_ENABLE_DATETIME_FORMAT_RFC // 启用其他RFC日期时间格式化
 
AST_CORE_CAPI errc_t aDateTimeFormatRFC1123(const DateTime& dttm, std::string& str);
 
 
AST_CORE_CAPI errc_t aDateTimeFormatRFC2822(const DateTime& dttm, std::string& str);
 
#endif
 
 
A_ALWAYS_INLINE errc_t aDateTimeFormatDefault(const DateTime& dttm, std::string& str, int precision = kTimeDefaultFormatPrecision)
{
    return aDateTimeFormatGregorian(dttm, str, precision);
}
 
 
 
// -------------
// 日期时间解析
// -------------
 
 
 
AST_CORE_CAPI errc_t aDateTimeParseISO8601(StringView str, DateTime& dttm);
 
 
A_ALWAYS_INLINE errc_t aDateTimeParseISO(StringView str, DateTime& dttm)
{
    return aDateTimeParseISO8601(str, dttm);
}
 
 
 
AST_CORE_CAPI errc_t aDateTimeParseRFC3339(StringView str, DateTime& dttm);
 
 
AST_CORE_CAPI errc_t aDateTimeParseGregorian(StringView str, DateTime& dttm);
 
 
 
AST_CORE_CAPI errc_t aDateTimeParseGregorianEn(StringView str, DateTime& dttm);
 
 
AST_CORE_CAPI errc_t aDateTimeParseGMT(StringView str, DateTime& dttm);
 
 
AST_CORE_CAPI errc_t aDateTimeParse(StringView str, StringView format, DateTime& dttm);
 
 
AST_CORE_CAPI errc_t aDateTimeParseAny(StringView str, DateTime& dttm);
 
 
class DateTime
{
public:
    enum ETimeZone{
        eUTC = 0,   
        eBJT = 8,   
    };
public:
    AST_CORE_API
    static DateTime FromJD(const JulianDate& jd);
 
    A_ALWAYS_INLINE
    static DateTime FromJulianDate(const JulianDate& jd){return FromJD(jd);}
 
    AST_CORE_API
    static DateTime FromString(StringView str, StringView format);
 
    AST_CORE_API
    static DateTime FromString(StringView str);
 
    AST_CORE_API
    static DateTime FromGregorian(StringView str);
 
 
    AST_CORE_API
    static DateTime FromTm(const tm* time);
 
    AST_CORE_API
    static DateTime FromTimeTLocal(time_t time);
 
    AST_CORE_API
    static DateTime FromTimeTUTC(time_t time);
 
    static DateTime Parse(StringView str){
        DateTime dttm;
        aDateTimeParseAny(str, dttm);
        return dttm;
    }
 
public: 
    const Date& date() const{return date_;}
    Date& date() {return date_;}
    const Time& time() const {return time_;}
    Time& time() {return time_;}
    int year() const {return date_.year();}
    int& year() {return date_.year();}
    int month() const {return date_.month();}
    int& month() {return date_.month();}
    int day() const {return date_.day();}
    int& day() {return date_.day();}
    int hour() const {return time_.hour();}
    int& hour() {return time_.hour();}
    int minute() const {return time_.minute();}
    int& minute() {return time_.minute();}
    double second() const {return time_.second();}
    double& second() {return time_.second();}
    int dayOfYear() const {return date_.dayOfYear();}
    int dayOfWeek() const {return date_.dayOfWeek();}
    double secOfDay() const {return time_.totalSecond();}
    void setYear(int year) {date_.setYear(year);}
    void setMonth(int month) {date_.setMonth(month);}
    void setDay(int day) {date_.setDay(day);}
    void setHour(int hour) {time_.setHour(hour);}
    void setMinute(int minute) {time_.setMinute(minute);}
    void setSecond(double second) {time_.setSecond(second);}
public:
    void normalize(){
        aDateTimeNormalize(*this);
    }
    void normalizeUTC(){
        aDateTimeNormalizeUTC(*this);
    }
    void normalizeLocal(int timezone){
        aDateTimeNormalizeLocal(*this, timezone);
    }
    void normalizeBJT(){
        aDateTimeNormalizeBJT(*this);
    }
    DateTime normalized() const{
        DateTime dttm = *this;
        dttm.normalize();
        return dttm;
    }
    DateTime normalizedUTC() const{
        DateTime dttm = *this;
        dttm.normalizeUTC();
        return dttm;
    }
    DateTime normalizedLocal(int timezone) const{
        DateTime dttm = *this;
        dttm.normalizeLocal(timezone);
        return dttm;
    }
    DateTime normalizedBJT() const{
        DateTime dttm = *this;
        dttm.normalizeBJT();
        return dttm;
    }
public:
    bool isInf() const{return time_.isInf();}
 
    std::string toString(int precision = 3) const{
        std::string str;
        aDateTimeFormatDefault(*this, str, precision);
        return str;
    }
public:
    void addYears(int years){
        aDateTimeAddYears(*this, years);
    }
    void addMonths(int months){
        aDateTimeAddMonths(*this, months);
    }
    void addDays(int days){
        aDateTimeAddDays(*this, days);
    }
    void addDaysUTC(int days){
        aDateTimeAddDaysUTC(*this, days);
    }
    void addDaysLocal(int days, int timezone){
        aDateTimeAddDaysLocal(*this, days, timezone);
    }
    void addDaysBJT(int days){
        aDateTimeAddDaysBJT(*this, days);
    }
    void addHours(int hours){
        aDateTimeAddHours(*this, hours);
    }
    void addHoursUTC(int hours){
        aDateTimeAddHoursUTC(*this, hours);
    }
    void addHoursLocal(int hours, int timezone){
        aDateTimeAddHoursLocal(*this, hours, timezone);
    }
    void addHoursBJT(int hours){
        aDateTimeAddHoursBJT(*this, hours);
    }
    void addMinutes(int minutes){
        aDateTimeAddMinutes(*this, minutes);
    }
    void addMinutesUTC(int minutes){
        aDateTimeAddMinutesUTC(*this, minutes);
    }
    void addMinutesLocal(int minutes, int timezone){
        aDateTimeAddMinutesLocal(*this, minutes, timezone);
    }
    void addMinutesBJT(int minutes){
        aDateTimeAddMinutesBJT(*this, minutes);
    }
    void addSeconds(double seconds){
        aDateTimeAddSeconds(*this, seconds);
    }
    void addSecondsUTC(double seconds){
        aDateTimeAddSecondsUTC(*this, seconds);
    }
    void addSecondsLocal(double seconds, int timezone){
        aDateTimeAddSecondsLocal(*this, seconds, timezone);
    }
    void addSecondsBJT(double seconds){
        aDateTimeAddSecondsBJT(*this, seconds);
    }
public:
    DateTime& operator += (double sec)
    {
        this->second() += sec;  // 适用于任何时间尺度，包括考虑闰秒的和不考虑闰秒的
        return *this;
    }
    DateTime& operator -= (double sec)
    {
        this->second() -= sec;  // 适用于任何时间尺度，包括考虑闰秒的和不考虑闰秒的
        return *this;
    }
    DateTime operator + (double sec) const
    {
        auto dttm = DateTime{ *this };
        dttm += sec;
        return dttm;
    }
    DateTime operator -(double sec) const
    {
        auto dttm = DateTime{ *this };
        dttm -= sec;
        return dttm;
    }
    
public:
    Date date_;     
    Time time_;     
};
 
A_ALWAYS_INLINE
DateTime aCurrentDateTimeLocal()
{
    DateTime dttm;
    aCurrentDateTimeLocal(dttm);
    return dttm;
}
 
A_ALWAYS_INLINE
DateTime aCurrentDateTimeUTC()
{
    DateTime dttm;
    aCurrentDateTimeUTC(dttm);
    return dttm;
}
 
 
AST_NAMESPACE_END