TimeInterval.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include "TimePoint.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);
 
 
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;
    }
 
    TimeInterval() = default;
    ~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 setStartStop(const TimePoint& start, const TimePoint& stop){
        start_ = start;
        stop_  = stop;
    }
 
    void setStartStop(const TimePoint& epoch, double start, double stop){
        start_ = epoch + start;
        stop_  = epoch + stop;
    }
 
    void setInfinite()
    {
        start_ = {0, -std::numeric_limits<double>::infinity()};
        stop_  = {0, +std::numeric_limits<double>::infinity()};
    }
    void setZero()
    {
        start_ = {0, 0.0};
        stop_  = {0, 0.0};
    }
public:
    double duration() const{return stop_ - start_;}
 
public:
    std::string toString() const{
        std::string strStart, strEnd;
        aTimeIntervalFormat(*this, strStart, strEnd);
        return strStart + " - " + strEnd;
    }
public:
    AST_CORE_API
    errc_t discrete(const TimePoint& epoch, double step, std::vector<double>& times) const;
 
    AST_CORE_API
    errc_t discrete(double step, std::vector<TimePoint>& times) const;
 
    AST_CORE_API
    errc_t discrete(double step, TimeList& times) const;
 
    class DiscreteTimePointRange;
    class DiscreteEpochSecondRange;
 
    DiscreteTimePointRange discrete(double step) const;
 
    DiscreteEpochSecondRange discrete(const TimePoint& epoch, double step) const;
public:
    errc_t merge(const TimeInterval& other);
private:
    TimePoint start_;     
    TimePoint stop_;      
};
 
 
class TimeInterval::DiscreteTimePointRange {
public:
    DiscreteTimePointRange(const TimeInterval& interval, double step, size_t n)
        : interval_(interval), step_(step), n_(n) {}
 
    class iterator {
    public:
        using iterator_category = std::input_iterator_tag;
        using value_type        = TimePoint;
        using difference_type   = ptrdiff_t;
        using pointer           = const TimePoint*;
        using reference         = const TimePoint&;
 
        iterator() = default;
        iterator(const DiscreteTimePointRange* range, size_t idx)
            : range_(range), idx_(idx), value_() {}
 
        reference operator*() const {
            if (idx_ == range_->n_ - 1) {
                value_ = range_->interval_.stop();
            } else {
                value_ = range_->interval_.start() + range_->step_ * idx_;
            }
            return value_;
        }
 
        iterator& operator++() { ++idx_; return *this; }
        iterator operator++(int) { auto tmp = *this; ++*this; return tmp; }
 
        bool operator==(const iterator& other) const { return idx_ == other.idx_; }
        bool operator!=(const iterator& other) const { return !(*this == other); }
 
    private:
        const DiscreteTimePointRange* range_ = nullptr;
        size_t idx_ = 0;
        mutable TimePoint value_{};
    };
 
    iterator begin() const { return iterator(this, 0); }
    iterator end()   const { return iterator(this, n_); }
    size_t size() const { return n_; }
 
private:
    TimeInterval interval_;
    double step_;
    size_t n_;
};
 
class TimeInterval::DiscreteEpochSecondRange {
public:
    DiscreteEpochSecondRange(double offset, double step, double stopOffset, size_t n)
        : offset_(offset), step_(step), stopOffset_(stopOffset), n_(n) {}
 
    class iterator {
    public:
        using iterator_category = std::input_iterator_tag;
        using value_type        = double;
        using difference_type   = ptrdiff_t;
        using pointer           = const double*;
        using reference         = const double&;
 
        iterator() = default;
        iterator(const DiscreteEpochSecondRange* range, size_t idx)
            : range_(range), idx_(idx), value_() {}
 
        reference operator*() const {
            if (idx_ == range_->n_ - 1) {
                value_ = range_->stopOffset_;
            } else {
                value_ = range_->offset_ + range_->step_ * idx_;
            }
            return value_;
        }
 
        iterator& operator++() { ++idx_; return *this; }
        iterator operator++(int) { auto tmp = *this; ++*this; return tmp; }
 
        bool operator==(const iterator& other) const { return idx_ == other.idx_; }
        bool operator!=(const iterator& other) const { return !(*this == other); }
 
    private:
        const DiscreteEpochSecondRange* range_ = nullptr;
        size_t idx_ = 0;
        mutable double value_{0.0};
    };
 
    iterator begin() const { return iterator(this, 0); }
    iterator end()   const { return iterator(this, n_); }
    size_t size() const { return n_; }
private:
    double offset_;
    double step_;
    double stopOffset_;
    size_t n_;
};
 
 
inline TimeInterval::DiscreteTimePointRange TimeInterval::discrete(double step) const
{
    double dur = duration();
    if (step <= 0.0 || dur <= 0.0) {
        return DiscreteTimePointRange(*this, step, 0);
    }
    size_t n = static_cast<size_t>(std::ceil(dur / step)) + 1;
    return DiscreteTimePointRange(*this, step, n);
}
 
inline TimeInterval::DiscreteEpochSecondRange TimeInterval::discrete(const TimePoint& epoch, double step) const
{
    double dur = duration();
    if (step <= 0.0 || dur <= 0.0) {
        return DiscreteEpochSecondRange(0.0, step, 0.0, 0);
    }
    size_t n = static_cast<size_t>(std::ceil(dur / step)) + 1;
    double offset = getStart() - epoch;
    double stopOffset = getStop() - epoch;
    return DiscreteEpochSecondRange(offset, step, stopOffset, n);
}
 
inline errc_t TimeInterval::merge(const TimeInterval &other)
{
    const TimePoint& thisStart = start();
    const TimePoint& otherStart = other.start();
    TimePoint thisStop = stop();
    TimePoint otherStop = other.stop();
 
    if (thisStart.durationFrom(otherStop) > 0 || otherStart.durationFrom(thisStop) > 0) 
    {
        aError("merge time interval failed, no overlap");
        return eErrorInvalidParam;
    }
 
    const TimePoint& mergedStart = (thisStart.durationFrom(otherStart) <= 0) ? thisStart : otherStart;
    const TimePoint& mergedStop = (thisStop.durationFrom(otherStop) >= 0) ? thisStop : otherStop;
 
    setStartStop(mergedStart, mergedStop);
    return eNoError;
}
 
AST_NAMESPACE_END