rate_counter.hpp

#pragma once

#include <memory>
#include <deque>
#include <numeric>
#include <iostream>

#include "../global.hpp"
#include "utilities.hpp"
#include "stop_watch.hpp"


namespace Cvb
{

CVB_BEGIN_INLINE_NS

namespace Utilities
{


class RateCounter
{
  public:


  
    static constexpr int MinimumWindowSize = 1;

    static constexpr int DefaultWindowSize = 25;

    static constexpr int MaximumWindowSize = 65535;


    static std::unique_ptr<RateCounter> Create()
    {
      return std::unique_ptr<RateCounter>();
    }


    static std::unique_ptr<RateCounter> Create(int windowSize)
    {
      return std::unique_ptr<RateCounter>(new RateCounter(windowSize));
    }


    static std::unique_ptr<RateCounter> Create(int windowSize, StopWatchMode mode)
    {
      return std::unique_ptr<RateCounter>(new RateCounter(windowSize, mode));
    }


    RateCounter()
      : stopWatch_(Cvb::StopWatchMode::MultiCPU)
    {
    }


    RateCounter(int windowSize)
      : stopWatch_(Cvb::StopWatchMode::MultiCPU)
      , windowSize_(windowSize)
    {

    }


    RateCounter(int windowSize, StopWatchMode mode)
      : stopWatch_(mode)
      , windowSize_(windowSize)
    {

    }


    RateCounter(RateCounter&& other) = default;


    RateCounter& operator=(RateCounter&& other) noexcept = default;






    StopWatchMode Mode() const noexcept
    {
      return stopWatch_.Mode();
    }


    int WindowSize() const noexcept
    {
      return windowSize_;
    }



    void SetWindowSize(int windowSize)
    {
      if (windowSize_ == windowSize)
        return;

      if (windowSize < MinimumWindowSize || windowSize > MaximumWindowSize)
        throw std::out_of_range("Window size out of range.");

      windowSize_ = windowSize;

      while (static_cast<int>(measurements_.size()) > windowSize_)
        measurements_.pop_front();
    }





    std::chrono::milliseconds AverageTimeSpan() const noexcept
    {
      double sum = std::accumulate(measurements_.begin(), measurements_.end(), 0.0);
      if (!measurements_.size())
        return std::chrono::milliseconds::zero();

      auto result = std::round(sum / static_cast<double>(measurements_.size()));
      return std::chrono::milliseconds(static_cast<std::chrono::milliseconds::rep>(result));
    }



    double Rate() const noexcept
    {
      if (measurements_.size() < 2)
        return std::numeric_limits<double>::quiet_NaN();

      auto averageTimeSpan = AverageTimeSpan();
      return 1000.0 / static_cast<double>(averageTimeSpan.count());
    }



    int NumSteps() const noexcept
    {
      return numSteps_;
    }


    void Reset() noexcept
    {
      measurements_.clear();
      lastReading_ = std::numeric_limits<double>::quiet_NaN();
      numSteps_ = 0;
    }


    void Step() noexcept
    {
      if (std::isnan(lastReading_))
      {
        lastReading_ = 0.0;
        stopWatch_.Start();
      }
      else
      {
        auto now = static_cast<double>(stopWatch_.TimeSpan().count());
        measurements_.push_back(now - lastReading_);
        lastReading_ = now;
        ++numSteps_;

        while (static_cast<int>(measurements_.size()) > windowSize_)
          measurements_.pop_front();
      }
    }






  private:

    StopWatch stopWatch_;

    int windowSize_ = DefaultWindowSize;

    std::deque<double> measurements_;

    double lastReading_ = std::numeric_limits<double>::quiet_NaN();

    int numSteps_ = 0;
};


}


CVB_END_INLINE_NS

}