TimePointRange.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include "TimePoint.hpp"
#include "AstUtil/Math.hpp"
#include <iterator>   // for std::input_iterator_tag
#include <cstddef>    // for size_t / ptrdiff_t
#include <cmath>
 
AST_NAMESPACE_BEGIN
 
 
class TimePointRange
{
public:
    TimePointRange(const TimePoint& start, const TimePoint& stop, double step, size_t n)
        : start_(start)
        , stop_(stop)
        , step_(step)
        , n_(n) 
    {}
 
    TimePointRange(const TimePoint& start, const TimePoint& stop, double step)
        : start_(start)
        , stop_(stop)
        , step_(step)
        , n_(aDiscretizedCount(stop - start, step))
    {}
 
    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         = TimePoint;   // input iterator：按值返回
 
        iterator() = default;
        iterator(const TimePointRange* range, size_t idx)
            : range_(range), idx_(idx) {}
 
        reference operator*() const
        {
            return (idx_ == range_->n_ - 1)
                       ? range_->stop_
                       : range_->start_ + range_->step_ * idx_;
        }
 
        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 TimePointRange* range_ = nullptr;
        size_t idx_ = 0;
    };
 
    iterator begin() const { return iterator(this, 0); }
    iterator end()   const { return iterator(this, n_); }
    size_t size() const { return n_; }
 
    TimePoint operator[](size_t i) const
    {
        return (i == n_ - 1) ? stop_ : start_ + step_ * i;
    }
 
    const TimePoint& start() const {return start_;}
    const TimePoint& stop() const{return stop_;}
    double step() const {return step_;}
 
private:
    TimePoint start_;     
    TimePoint stop_;      
    double    step_;      
    size_t    n_;         
};
 
 
AST_NAMESPACE_END