TimeInterval.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include "TimePoint.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:
    TimeInterval() = default;
    ~TimeInterval() = default;
 
    TimeInterval(const TimePoint& start, const TimePoint& stop){
        this->setStartStop(start, stop);
    }
 
    TimeInterval(const TimePoint& epoch, double start, double stop)
    {
        this->setStartStop(epoch, start, stop);
    }
 
    const TimePoint& start() const{return reinterpret_cast<const TimePoint&>(*this);}
 
    const TimePoint& getStart() const{return reinterpret_cast<const TimePoint&>(*this);}
 
    TimePoint stop() const{return {epoch_, stop_};}
 
    TimePoint getStop() const{return {epoch_, stop_};}
 
 
    void setStartStop(const TimePoint& start, const TimePoint& stop){
        epoch_ = start.integerPart();
        start_ = start.fractionalPart();
        stop_ = stop.fractionalPart() + (stop.integerPart() - start.integerPart());
    }
 
    void setStartStop(const TimePoint& epoch, double start, double stop){
        epoch_ = epoch.integerPart();
        start_ = epoch.fractionalPart() + start;
        stop_ = epoch.fractionalPart() + stop;
    }
 
    void setInfinite()
    {
        epoch_ = 0;
        start_ = -std::numeric_limits<double>::infinity();
        stop_  = +std::numeric_limits<double>::infinity();
    }
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;
 
    class DiscreteTimePointRange;
    class DiscreteEpochSecondRange;
 
    DiscreteTimePointRange discrete(double step) const;
 
    DiscreteEpochSecondRange discrete(const TimePoint& epoch, double step) const;
 
protected:
    int64_t epoch_;     
    double  start_;     
    double  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) {}
 
        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) {}
 
        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_;
    };
 
    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));
    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));
    double offset = getStart() - epoch;
    double stopOffset = getStop() - epoch;
    return DiscreteEpochSecondRange(offset, step, stopOffset, n);
}
 
AST_NAMESPACE_END