TimeList.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include "TimePoint.hpp"
#include <iterator>
#include <vector>
 
AST_NAMESPACE_BEGIN
 
 
class TimeList
{
public:
 
    // ————————————————————————
    // 工厂方法
    // ————————————————————————
 
    AST_CORE_API
    static TimeList FromInterval(const TimeInterval& interval, const TimePoint& epoch, double step);
 
    AST_CORE_API
    static TimeList FromInterval(const TimeInterval& interval, double step);
 
public:
 
    TimeList() = default;
 
    ~TimeList() = default;
 
    TimeList(const TimeList&) = default;
 
    TimeList& operator=(const TimeList&) = default;
 
    TimeList(TimeList&&) noexcept = default;
 
    TimeList& operator=(TimeList&&) noexcept = default;
 
    TimeList(const TimePoint& epoch, const std::vector<double>& secs)
        : seconds_(secs), epoch_(epoch) {}
 
    TimeList(const TimePoint& epoch, std::vector<double>&& secs)
        : seconds_(std::move(secs)), epoch_(epoch) {}
 
    TimeList(const TimePoint& epoch)
        : epoch_(epoch)
    {
    }
    
 
    // ————————————————————————
    // 容量
    // ————————————————————————
 
    size_t size()  const noexcept { return seconds_.size(); }
    bool   empty() const noexcept { return seconds_.empty(); }
 
    void resize(size_t n)          { seconds_.resize(n); }
    void reserve(size_t n)         { seconds_.reserve(n); }
    void clear()                   { seconds_.clear(); }
 
 
    // ————————————————————————
    // 修改
    // ————————————————————————
 
    void push_back(const TimePoint& tp)        { seconds_.push_back(tp - epoch_); }
    void pop_back()                            { seconds_.pop_back(); }
 
    // ————————————————————————
    // 参考历元
    // ————————————————————————
 
    const TimePoint& epoch() const { return epoch_; }
 
    void setEpoch(const TimePoint& epoch) { epoch_ = epoch; }
 
    // ————————————————————————
    // 底层向量访问
    // ————————————————————————
 
    std::vector<double>&       seconds()       noexcept { return seconds_; }
    const std::vector<double>& seconds() const noexcept { return seconds_; }
 
    // ————————————————————————
    // 时间语义
    // ————————————————————————
 
    TimePoint timePoint(size_t i) const
    {
        return epoch_.shiftedBySecond(seconds_[i]);
    }
 
    TimePoint operator[](size_t i) const { return epoch_.shiftedBySecond(seconds_[i]); }
 
    TimePoint at(size_t i) const { return epoch_.shiftedBySecond(seconds_.at(i)); }
 
    // ————————————————————————
    // 迭代器
    // ————————————————————————
 
    class const_iterator
    {
    public:
        using iterator_category = std::random_access_iterator_tag;
        using value_type        = TimePoint;
        using difference_type   = std::ptrdiff_t;
        using pointer           = const TimePoint*;
        using reference         = TimePoint;  // 按值返回
 
        const_iterator() = default;
 
        const_iterator(const double* data, const TimePoint* epoch)
            : data_(data), epoch_(epoch) {}
 
        TimePoint operator*() const { return epoch_->shiftedBySecond(*data_); }
 
        TimePoint operator[](difference_type n) const { return epoch_->shiftedBySecond(data_[n]); }
 
        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 double*    data_  = nullptr;
        const TimePoint* epoch_ = nullptr;
    };
 
    friend const_iterator operator+(typename const_iterator::difference_type n, const const_iterator& it)
    {
        return it + n;
    }
 
    using iterator               = const_iterator;
    using value_type             = TimePoint;
    using size_type              = size_t;
    using difference_type        = std::ptrdiff_t;
 
    iterator       begin()       { return {seconds_.data(), &epoch_}; }
    iterator       end()         { return {seconds_.data() + seconds_.size(), &epoch_}; }
    const_iterator begin() const { return {seconds_.data(), &epoch_}; }
    const_iterator end()   const { return {seconds_.data() + seconds_.size(), &epoch_}; }
    const_iterator cbegin()const { return begin(); }
    const_iterator cend()  const { return end(); }
 
private:
    std::vector<double> seconds_;   
    TimePoint           epoch_{};   
};
 
 
AST_NAMESPACE_END