ahNow.H

/* Aleph-w

     / \  | | ___ _ __ | |__      __      __
    / _ \ | |/ _ \ '_ \| '_ \ ____\ \ /\ / / Data structures & Algorithms
   / ___ \| |  __/ |_) | | | |_____\ V  V /  version 1.9b
  /_/   \_\_|\___| .__/|_| |_|      \_/\_/   https://github.com/lrleon/Aleph-w
                 |_|         

  This file is part of Aleph-w library

  Copyright (c) 2002-2018 Leandro Rabindranath Leon & Alejandro Mujica

  This program is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
# ifndef AHNOW_H
# define AHNOW_H

# include <string>
# include <chrono>

# include <aleph.H>

using namespace std;
using namespace chrono;
using namespace Aleph;

namespace Aleph
{
  class Now
  {
  public:
    enum class Precision
      {
        Hours,
        Minutes,
        Seconds,
        Milliseconds,
        Microseconds,
        Nanoseconds
      };

    static int to_int(Precision p)
    {
      return static_cast<int>(p);
    }
    
    using ClockType = high_resolution_clock;
    using TimePointType = ClockType::time_point;
    using DurationType = ClockType::duration;

  private:
    TimePointType tp;

    Precision precision;

    static const double precision_values[];
    
  public:
    static TimePointType current_time_point()
    {
      return ClockType::now();
    }

    static double compute_time_diff(const TimePointType & rtp,
                                    const TimePointType & ltp,
                                    const Precision & precision)
    {
      DurationType et = std::chrono::duration_cast<nanoseconds>(rtp - ltp);
      return et.count() * precision_values[to_int(precision)];
    }

    Now(bool start_now = false)
      : tp(), precision(Precision::Milliseconds)
    {
      if (start_now)
        start();
    }

    Now(const Precision & _precision, bool start_now = false)
      : tp(), precision(_precision)
    {
      if (start_now)
        start();
    }

    const Precision & get_precision() const
    {
      return precision;
    }

    void set_precision(const Precision & _precision)
    {
      precision = _precision;
    }

    TimePointType start()
    {
      tp = this->current_time_point();
      return tp;
    }

    double elapsed()
    {
      TimePointType ltp = tp;
      tp = this->current_time_point();
      return compute_time_diff(tp, ltp, precision);
    }

    double delta()
    {
      return elapsed();
    }

    static double elapsed(const TimePointType & tp,
                          const Precision & precision = Precision::Milliseconds)
    {
      return compute_time_diff(current_time_point(), tp, precision);
    }

    static double delta(const TimePointType & tp,
                        const Precision & precision = Precision::Milliseconds)
    {
      return elapsed(tp, precision);
    }
  };  
} // End namespace Aleph
  
# endif // AHNOW_H