TimePoint.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include "Duration.hpp"             // for LongDuration
#include "AstCore/Constants.h"      // for kJ2000XXXX
#include "AstCore/JulianDate.hpp"    
#include "AstCore/DateTime.hpp"
#include "AstCore/RunTime.hpp"
#include "AstUtil/StringView.hpp"
#include <stdint.h>                 // for int64_t
#include <cmath>                    // for std::isnan
 
AST_NAMESPACE_BEGIN
 
class DateTime;
 
class LongDuration;
class ShortDuration;
class DaySecDuration;
 
class TAIScale;
class TDBScale;
class TTScale;
class UTCScale;
 
class TimePoint;
 
constexpr static int kTimePointDefaultFormatPrecision = 6;
 
 
// --------------------
// 时间点与时间系统的转换
// --------------------
 
AST_CORE_API void aTimePointToUTC(const TimePoint& time, JulianDate& jdUTC);
 
AST_CORE_API void aTimePointToTT(const TimePoint& time, JulianDate& jdTT);
 
AST_CORE_API void aTimePointToTDB(const TimePoint& time, JulianDate& jdTDB);
 
AST_CORE_API void aTimePointToTAI(const TimePoint& time, JulianDate& jdTAI);
 
AST_CORE_API void aTimePointToUT1(const TimePoint& time, JulianDate& jdUT1);
 
AST_CORE_API void aTimePointToUTC(const TimePoint& time, DateTime& dttmUTC);
 
AST_CORE_API void aTimePointToTT(const TimePoint& time, DateTime& dttmTT);
 
AST_CORE_API void aTimePointToTDB(const TimePoint& time, DateTime& dttmTDB);
 
AST_CORE_API void aTimePointToTAI(const TimePoint& time, DateTime& dttmTAI);
 
AST_CORE_API void aTimePointToUT1(const TimePoint& time, DateTime& dttmUT1);
 
 
 
// ----------------
// 时间点格式化与解析
// ----------------
 
 
AST_CORE_CAPI errc_t aTimePointFormat(const TimePoint& time, std::string& str, int precision = kTimePointDefaultFormatPrecision);
 
AST_CORE_CAPI errc_t aTimePointParse(StringView str, TimePoint& time);
 
 
class TimePoint
{
public:
    AST_CORE_API
    static TimePoint Default();
 
    AST_CORE_API
    static TimePoint NaN();
 
    AST_CORE_API
    static TimePoint Epoch();
 
    AST_CORE_API
    static TimePoint CurrentTime();
 
    AST_CORE_API 
    static TimePoint TodayUTC();
 
    AST_CORE_API
    static TimePoint TomorrowUTC();
 
    AST_CORE_API
    static TimePoint FromUTC(int year, int month, int day, int hour, int minute, double second);
 
    AST_CORE_API
    static TimePoint FromUTC(const DateTime& dttmUTC);
 
    AST_CORE_API
    static TimePoint FromYD(int year, double dayOfYear);
 
    AST_CORE_API
    static TimePoint FromTLEYD(double tleYD);
 
    AST_CORE_API
    static TimePoint FromBJT(const DateTime& dttmBJT);
 
    AST_CORE_API
    static TimePoint FromTAI(const DateTime& dttmTAI);
 
    AST_CORE_API 
    static TimePoint FromTAI(const JulianDate& jdTAI);
 
    AST_CORE_API
    static TimePoint FromTT(const JulianDate& jdTT);
 
    AST_CORE_API
    static TimePoint FromTT(const DateTime& dttmTT);
 
    AST_CORE_API 
    static TimePoint FromTDB(const JulianDate& jdTDB);
 
    AST_CORE_API
    static TimePoint FromImpreciseJDTT(double jdTT);
 
    static TimePoint J2000TT(){
        return {0, -kTTMinusTAI};
    }
 
    AST_CORE_API
    static TimePoint Parse(StringView str);
 
    AST_CORE_API
    static TimePoint ParseUTC(StringView str);
 
    AST_CORE_API
    static TimePoint ParseBJT(StringView str);
public:
    int64_t integerPart() const { return duration_.integer_; }
 
    double fractionalPart() const { return duration_.fractional_; }
 
    bool isNaN() const { return std::isnan(duration_.fractional_); }
 
    bool isValid() const { return !isNaN(); }
public:
    double daysFromJ2000TT() const{
        return ((double)integerPart() / kSecondsPerDay) + (fractionalPart() + kTTMinusTAI) / kSecondsPerDay;
    }
 
    double julianCenturyFromJ2000TT() const{
        return daysFromJ2000TT() / kDaysPerJulianCentury;
    }
 
    void toTT(JulianDate& jdTT) const{
        aTimePointToTT(*this, jdTT);
    }
    JulianDate toTT() const{
        JulianDate jdTT;
        toTT(jdTT);
        return jdTT;
    }
    void toTDB(JulianDate& jdTDB) const{
        aTimePointToTDB(*this, jdTDB);
    }
    JulianDate toTDB() const{
        JulianDate jdTDB;
        toTDB(jdTDB);
        return jdTDB;
    }
    void toTAI(JulianDate& jdTAI) const{
        aTimePointToTAI(*this, jdTAI);
    }
    JulianDate toTAI() const{
        JulianDate jdTAI;
        toTAI(jdTAI);
        return jdTAI;
    }
    double toEpochSecond() const{
        return aTimePointToEpochSecond(*this);
    }
 
    double durationFrom(const TimePoint& other) const{
        return duration_.minusInSecond(other.duration_);
    }
 
    double daysFrom(const TimePoint& other) const{
        return duration_.minusInDay(other.duration_);
    }
 
public:
    // ————————————————————————
    // 运算符重载
    // ————————————————————————
 
    double operator-(const TimePoint& other) const { return durationFrom(other); }
    TimePoint operator+(double second) const { return {integerPart(), fractionalPart() + second}; }
    TimePoint operator-(double second) const { return {integerPart(), fractionalPart() - second}; }
    TimePoint& operator+=(double second) { duration_.fractional_ += second; return *this; }
    TimePoint& operator-=(double second) { duration_.fractional_ -= second; return *this; }
    bool operator==(const TimePoint& other) const { return durationFrom(other) == 0.0; }
    bool operator!=(const TimePoint& other) const { return durationFrom(other) != 0.0; }
    bool operator>(const TimePoint& other) const { return durationFrom(other) > 0.0; }
    bool operator<(const TimePoint& other) const { return durationFrom(other) < 0.0; }
    bool operator>=(const TimePoint& other) const { return durationFrom(other) >= 0.0; }
    bool operator<=(const TimePoint& other) const { return durationFrom(other) <= 0.0; }
 
public:
 
    std::string toString(int precision = kTimePointDefaultFormatPrecision) const
    {
        std::string str;
        aTimePointFormat(*this, str, precision);
        return str;
    }
public:
    TimePoint shiftedBySecond(double second) const{
        return {integerPart(), fractionalPart() + second};
    }
    
    AST_CORE_API TimePoint shiftedBySecondInTDB(double second) const;
    
protected:
    static TimePoint FromIntegerFractional(int64_t integer, double fractional);
public:
    LongDuration    duration_;
};
 
 
inline TimePoint operator ""_utc(const char* str, size_t len)
{
    return TimePoint::ParseUTC(StringView(str, len));
}
 
inline TimePoint operator ""_bjt(const char* str, size_t len)
{
    return TimePoint::ParseBJT(StringView(str, len));
}
 
inline TimePoint operator ""_timepoint(const char* str, size_t len)
{
    return TimePoint::Parse(StringView(str, len));
}
 
// typedef TimePoint<TDBScale, LongDuration> TDBTime;
// typedef TimePoint<TTScale, LongDuration> TTTime;
// typedef TimePoint<UTCScale, LongDuration> UTCTime;
// typedef TimePoint<TAIScale, LongDuration> TAITime;
 
// typedef TAITime AbsTime;
// typedef TAITime AstTime;
 
 
AST_NAMESPACE_END