TimeIntervalList.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include "TimePoint.hpp"
#include "IntervalList.hpp"
#include "TimeInterval.hpp"
#include "TimeList.hpp"
#include <vector>
#include <iterator>     // for std::random_access_iterator_tag
 
AST_NAMESPACE_BEGIN
 
 
class TimeIntervalList
{
public:
 
    // ————————————————————————
    // 工厂方法
    // ————————————————————————
 
    AST_CORE_API
    static TimeIntervalList FromTimeInterval(const TimeInterval& interval);
 
    AST_CORE_API
    static TimeIntervalList FromTimeIntervals(const std::vector<TimeInterval>& intervals);
 
    AST_CORE_API
    static TimeIntervalList FromTimeIntervals(const std::vector<TimeInterval>& intervals, const TimePoint& epoch);
 
    AST_CORE_API
    static TimeIntervalList FromIntervals(const std::vector<Interval>& intervals, const TimePoint& epoch);
 
    AST_CORE_API
    static TimeIntervalList FromIntervalList(const IntervalList& list, const TimePoint& epoch);
 
public:
 
    // ————————————————————————
    // 构造与生命周期
    // ————————————————————————
 
    TimeIntervalList() = default;
 
    ~TimeIntervalList() = default;
 
    TimeIntervalList(const TimeIntervalList&) = default;
 
    TimeIntervalList& operator=(const TimeIntervalList&) = default;
 
    TimeIntervalList(TimeIntervalList&&) noexcept = default;
 
    TimeIntervalList& operator=(TimeIntervalList&&) noexcept = default;
 
    TimeIntervalList(const TimePoint& epoch)
        : epoch_(epoch) {}
 
    // ————————————————————————
    // 容量
    // ————————————————————————
 
    size_t size() const noexcept { return intervals_.size(); }
 
    bool empty() const noexcept { return intervals_.empty(); }
 
    void reserve(size_t n) { intervals_.reserve(n); }
 
    void clear() { intervals_.clear(); }
 
    // ————————————————————————
    // 元素访问
    // ————————————————————————
 
    AST_CORE_API
    TimeInterval operator[](size_t i) const;
 
    AST_CORE_API
    TimeInterval at(size_t i) const;
 
    // ————————————————————————
    // 修改
    // ————————————————————————
 
    AST_CORE_API
    void push_back(const TimeInterval& ti);
 
    AST_CORE_API
    void push_back(const TimePoint& start, const TimePoint& stop);
 
    void pop_back() { intervals_.pop_back(); }
 
    // ————————————————————————
    // 历元
    // ————————————————————————
 
    const TimePoint& epoch() const noexcept { return epoch_; }
 
    void setEpoch(const TimePoint& epoch) { epoch_ = epoch; }
 
    // ————————————————————————
    // 底层容器访问
    // ————————————————————————
 
    IntervalList& intervals() noexcept { return intervals_; }
 
    const IntervalList& intervals() const noexcept { return intervals_; }
 
    // ————————————————————————
    // 查询
    // ————————————————————————
 
    double totalDuration() const { return intervals_.totalDuration(); }
 
    AST_CORE_API
    bool contains(const TimePoint& t) const;
 
    // ————————————————————————
    // 集合运算
    // ————————————————————————
 
    AST_CORE_API
    TimeIntervalList merged() const;
 
    AST_CORE_API
    void mergeInPlace();
 
    AST_CORE_API
    TimeIntervalList& intersect(const TimeIntervalList& other);
 
    AST_CORE_API
    TimeIntervalList& unite(const TimeIntervalList& other);
 
    AST_CORE_API
    TimeIntervalList& subtract(const TimeIntervalList& other);
 
    AST_CORE_API
    TimeIntervalList intersected(const TimeIntervalList& other) const;
 
    AST_CORE_API
    bool intersects(const TimeIntervalList& other) const;
 
    AST_CORE_API
    TimeIntervalList united(const TimeIntervalList& other) const;
 
    AST_CORE_API
    TimeIntervalList subtracted(const TimeIntervalList& other) const;
 
    // ————————————————————————
    // 运算符重载（Qt / Boost.ICL 风格）
    // ————————————————————————
 
    TimeIntervalList& operator&=(const TimeIntervalList& other) { return intersect(other); }
 
    TimeIntervalList& operator|=(const TimeIntervalList& other) { return unite(other); }
 
    TimeIntervalList& operator-=(const TimeIntervalList& other) { return subtract(other); }
 
    TimeIntervalList operator&(const TimeIntervalList& other) const { return intersected(other); }
 
    TimeIntervalList operator|(const TimeIntervalList& other) const { return united(other); }
 
    TimeIntervalList operator-(const TimeIntervalList& other) const { return subtracted(other); }
 
    // ————————————————————————
    // 转换
    // ————————————————————————
 
    IntervalList toIntervalList() const { return intervals_; }
 
    TimeList discretize(double step) const { return intervals_.discretize(epoch_, step); }
 
    TimeList discretize(const TimePoint& epoch, double step) const { return intervals_.discretize(epoch, step); }
 
    AST_CORE_API
    std::string toString(int precision = kTimePointDefaultFormatPrecision) const;
 
    // ————————————————————————
    // 迭代器
    // ————————————————————————
 
    class const_iterator
    {
    public:
        using iterator_category = std::random_access_iterator_tag;
        using value_type        = TimeInterval;
        using difference_type   = std::ptrdiff_t;
        using pointer           = const TimeInterval*;
        using reference         = TimeInterval;  // 按值返回
 
        const_iterator() = default;
 
        const_iterator(const Interval* data, const TimePoint* epoch)
            : data_(data), epoch_(epoch) {}
 
        TimeInterval operator*() const
        {
            return TimeInterval(epoch_->shiftedBySecond(data_->start_), epoch_->shiftedBySecond(data_->stop_));
        }
 
        TimeInterval operator[](difference_type n) const
        {
            return TimeInterval(epoch_->shiftedBySecond(data_[n].start_), epoch_->shiftedBySecond(data_[n].stop_));
        }
 
        const_iterator& operator++()                           { ++data_; return *this; }
        const_iterator  operator++(int)                        { auto tmp = *this; ++data_; return tmp; }
        const_iterator& operator--()                           { --data_; return *this; }
        const_iterator  operator--(int)                        { auto tmp = *this; --data_; return tmp; }
        const_iterator& operator+=(difference_type n)          { data_ += n; return *this; }
        const_iterator& operator-=(difference_type n)          { data_ -= n; return *this; }
 
        const_iterator  operator+(difference_type n)  const    { return {data_ + n, epoch_}; }
        const_iterator  operator-(difference_type n)  const    { return {data_ - n, epoch_}; }
        difference_type operator-(const const_iterator& o) const { return data_ - o.data_; }
 
        bool operator==(const const_iterator& o) const { return data_ == o.data_; }
        bool operator!=(const const_iterator& o) const { return data_ != o.data_; }
        bool operator< (const const_iterator& o) const { return data_ <  o.data_; }
        bool operator> (const const_iterator& o) const { return data_ >  o.data_; }
        bool operator<=(const const_iterator& o) const { return data_ <= o.data_; }
        bool operator>=(const const_iterator& o) const { return data_ >= o.data_; }
 
    private:
        const Interval* data_  = nullptr;
        const TimePoint* epoch_ = nullptr;
    };
 
    friend const_iterator operator+(const_iterator::difference_type n, const const_iterator& it)
    {
        return it + n;
    }
 
    using iterator               = const_iterator;
    using value_type             = TimeInterval;
    using size_type              = size_t;
    using difference_type        = std::ptrdiff_t;
 
    iterator       begin()       { return {intervals_.intervals().data(), &epoch_}; }
    iterator       end()         { return {intervals_.intervals().data() + intervals_.size(), &epoch_}; }
    const_iterator begin() const { return {intervals_.intervals().data(), &epoch_}; }
    const_iterator end()   const { return {intervals_.intervals().data() + intervals_.size(), &epoch_}; }
    const_iterator cbegin()const { return begin(); }
    const_iterator cend()  const { return end(); }
 
private:
    TimePoint    epoch_{};   
    IntervalList intervals_{}; 
};
 
 
AST_NAMESPACE_END