TimeInterval.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include "TimePoint.hpp"
#include "TimePointRange.hpp"
#include "DoubleRange.hpp"
#include "Interval.hpp"
#include "AstUtil/Logger.hpp"
#include <string>
#include <limits>
#include <vector>
#include <cmath>
 
AST_NAMESPACE_BEGIN
 
 
 
class TimeInterval;
 
AST_CORE_CAPI errc_t aTimeIntervalFormat(const TimeInterval& interval, std::string& strStart, std::string& strEnd, int precision = kTimePointDefaultFormatPrecision);
 
 
AST_CORE_CAPI errc_t aTimeIntervalParse(StringView strStart, StringView strEnd, TimeInterval& interval);
 
 
class TimeInterval
{
public:
    static TimeInterval Parse(StringView strStart, StringView strEnd)
    {
        TimeInterval interval;
        aTimeIntervalParse(strStart, strEnd, interval);
        return interval;
    }
 
    static TimeInterval Empty() {
        return TimeInterval(TimePoint{0, +std::numeric_limits<double>::infinity()},
                            TimePoint{0, -std::numeric_limits<double>::infinity()});
    }
 
    static TimeInterval Whole()
    {
        return TimeInterval(TimePoint{0, -std::numeric_limits<double>::infinity()},
                            TimePoint{0, +std::numeric_limits<double>::infinity()});
    }
 
public:
    TimeInterval() 
        : start_{}
        , stop_{} 
    {}
    ~TimeInterval() = default;
 
    TimeInterval(const TimePoint& start, const TimePoint& stop)
        : start_(start), stop_(stop) {}
 
    TimeInterval(const TimePoint& epoch, double start, double stop)
        : start_(epoch + start), stop_(epoch + stop) {}
 
    const TimePoint& start() const{return start_;}
 
    const TimePoint& getStart() const{return start_;}
 
    void setStart(const TimePoint& start){start_ = start;}
 
    const TimePoint& stop() const{return stop_;}
 
    const TimePoint& getStop() const{return stop_;}
 
    void setStop(const TimePoint& stop){stop_ = stop;}
 
    void setBounds(TimePoint start, TimePoint stop){
        start_ = start;
        stop_  = stop;
    }
 
    void setBounds(TimePoint epoch, double start, double stop){
        start_ = epoch + start;
        stop_  = epoch + stop;
    }
 
    void setBounds(TimePoint epoch, const Interval& interval){
        start_ = epoch + interval.start();
        stop_  = epoch + interval.stop();
    }
 
    Interval toInterval(const TimePoint& epoch) const
    {
        return Interval{getStart() - epoch, getStop() - epoch};
    }
 
    void setWhole()
    {
        start_ = {0, -std::numeric_limits<double>::infinity()};
        stop_  = {0, +std::numeric_limits<double>::infinity()};
    }
    void setEmpty()
    {
        start_ = {0, +std::numeric_limits<double>::infinity()};
        stop_  = {0, -std::numeric_limits<double>::infinity()};
    }
public:
    double duration() const{return stop_ - start_;}
 
    bool isEmpty() const { return !(start_ <= stop_); }
    bool isPoint() const { return start_ == stop_; }
    bool isDegenerate() const { return isPoint(); }
    bool isValid() const { return start_ <= stop_; }
    bool isNonEmpty() const { return isValid(); }
    bool contains(const TimePoint& t) const { return start_ <= t && t <= stop_; }
    bool contains(const TimeInterval& interval) const { return start_ <= interval.start() && interval.stop() <= stop_; }
    bool isWhole() const{return start_.isInf() && stop_.isInf();}
    bool isInf() const {return start_.isInf() || stop_.isInf();}
public:
    std::string toString(int precision = kTimePointDefaultFormatPrecision) const{
        std::string strStart, strEnd;
        aTimeIntervalFormat(*this, strStart, strEnd, precision);
        return strStart + " - " + strEnd;
    }
public:
    AST_CORE_API
    errc_t discretize(const TimePoint& epoch, double step, std::vector<double>& times) const;
 
    AST_CORE_API
    errc_t discretize(double step, std::vector<TimePoint>& times) const;
 
    AST_CORE_API
    errc_t discretize(double step, TimeList& times) const;
 
    TimePointRange discretize(double step) const;
 
    DoubleRange discretize(const TimePoint& epoch, double step) const;
 
    size_t discretizedCount(double step) const
    {
        double dur = duration();
        if (step > 0 && dur >= 0)
        {
            return aDiscretizedCount(dur, step);
        }
        // 如果存在nan，则duration()为nan，if 条件不成立，返回0
        return 0;
    }
public:
    AST_CORE_API
    TimeInterval& unite(const TimeInterval& other);
 
    AST_CORE_API
    TimeInterval united(const TimeInterval& other) const;
 
    AST_CORE_API
    TimeInterval& intersect(const TimeInterval& other);
 
    AST_CORE_API
    TimeInterval intersected(const TimeInterval& other) const;
 
    AST_CORE_API
    bool intersects(const TimeInterval& other) const;
 
    TimeInterval& operator|=(const TimeInterval& other) { return unite(other); }
 
    TimeInterval operator|(const TimeInterval& other) const { return united(other); }
 
    TimeInterval& operator&=(const TimeInterval& other) { return intersect(other); }
 
    TimeInterval operator&(const TimeInterval& other) const { return intersected(other); }
private:
    TimePoint start_;     
    TimePoint stop_;      
};
 
 
inline TimePointRange TimeInterval::discretize(double step) const
{
    double dur = duration();
    if (step > 0 && dur >= 0)
    {
        size_t n = aDiscretizedCount(dur, step);
        return TimePointRange(start_, stop_, step, n);
    }
    return TimePointRange(start_, stop_, step, 0);
}
 
inline DoubleRange TimeInterval::discretize(const TimePoint& epoch, double step) const
{
    double dur = duration();
    if (step > 0 && dur >= 0)
    {
        double start = getStart() - epoch;
        double stop  = getStop()  - epoch;
        return DoubleRange(start, stop, step);
    }
 
    return DoubleRange(0.0, 0.0, step, 0);
}
 
#ifndef SWIG
 
A_ALWAYS_INLINE bool operator==(const TimeInterval& lhs, const TimeInterval& rhs)
{
    return lhs.start() == rhs.start() && lhs.stop() == rhs.stop();
}
 
A_ALWAYS_INLINE bool operator!=(const TimeInterval& lhs, const TimeInterval& rhs)
{
    return !(lhs == rhs);
}
 
#endif
 
AST_NAMESPACE_END