now.H

Go to the documentation of this file.

/*
  This file is part of Designar.
  Copyright (C) 2017 by Alejandro J. 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 <http://www.gnu.org/licenses/>.

  Any user request of this software, write to 

  Alejandro Mujica

  aledrums@gmail.com
*/

# ifndef DSGNOW_H
# define DSGNOW_H

# include <types.H>

namespace Designar
{
  class Now
  {
  public:
    enum class Precision
      {
    HOURS,
    MINUTES,
        SECONDS,
        MILLISECONDS,
        MICROSECONDS,
    NANOSECONDS
      };

    static int to_int(Precision p)
    {
      return static_cast<int>(p);
    }
    
  private:
    time_point_t tp;

    Precision precision;

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

    static double compute_time_diff(const time_point_t & rtp,
                    const time_point_t & ltp,
                    const Precision & precision)
    {
      duration_t et = std::chrono::duration_cast<std::chrono::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;
    }

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

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

    double delta()
    {
      return elapsed();
    }

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

    static double delta(const time_point_t & tp,
            const Precision & precision = Precision::MILLISECONDS)
    {
      return elapsed(tp, precision);
    }
  };
  
} // End namespace Designar
  
# endif // DSGNOW_H