nimble::quanta::stopwatch Struct Reference

#include <nimble.quanta.stopwatch.h>

Public Types
typedef decltype(std::chrono::high_resolution_clock::now())	time
typedef std::chrono::duration< double, std::ratio< 1, 1 > >	seconds
typedef std::chrono::duration< double, std::milli >	milliseconds
typedef std::chrono::duration< double, std::micro >	microseconds
typedef decltype((time{} - time{}).count())	nanoseconds
typedef decltype((time{} - time{}))	duration

Public Member Functions
nanoseconds	age_nano ()
double	age_micro ()
double	age_milli ()
double	age ()
void	reset ()

Static Public Member Functions
template<class Function, class... Args>
static double	timefunction (Function &&f, Args &&... inputs)
static std::string	get_nanosecond_timestamp ()
static std::string	get_microsecond_timestamp ()
static std::string	get_millisecond_timestamp ()

Public Attributes
time	_start = std::chrono::high_resolution_clock::now()

Member Typedef Documentation

duration

typedef decltype((time{} - time{})) nimble::quanta::stopwatch::duration

microseconds

typedef std::chrono::duration<double, std::micro> nimble::quanta::stopwatch::microseconds

milliseconds

typedef std::chrono::duration<double, std::milli> nimble::quanta::stopwatch::milliseconds

nanoseconds

typedef decltype((time{} - time{}).count()) nimble::quanta::stopwatch::nanoseconds

seconds

typedef std::chrono::duration<double, std::ratio<1, 1> > nimble::quanta::stopwatch::seconds

time

typedef decltype(std::chrono::high_resolution_clock::now()) nimble::quanta::stopwatch::time

Member Function Documentation

age()

double nimble::quanta::stopwatch::age ( )

inline

  {
    return seconds(std::chrono::high_resolution_clock::now() - _start).count();
  }

age_micro()

double nimble::quanta::stopwatch::age_micro ( )

inline

  {
    return microseconds(std::chrono::high_resolution_clock::now() - _start).count();
  }

age_milli()

double nimble::quanta::stopwatch::age_milli ( )

inline

  {
    return milliseconds(std::chrono::high_resolution_clock::now() - _start).count();
  }

age_nano()

nanoseconds nimble::quanta::stopwatch::age_nano ( )

inline

  {
    return (std::chrono::high_resolution_clock::now() - _start).count();
  }

get_microsecond_timestamp()

static std::string nimble::quanta::stopwatch::get_microsecond_timestamp ( )

inlinestatic

  {
    auto epoch_duration      = std::chrono::high_resolution_clock::now().time_since_epoch();
    auto duration_in_seconds = std::chrono::duration_cast<std::chrono::seconds>(epoch_duration);
    auto microseconds =
        (std::chrono::duration_cast<std::chrono::microseconds>(epoch_duration - duration_in_seconds).count());
    std::time_t t = duration_in_seconds.count();
    char        buffer[100]{};
    size_t      end;
    if ((end = std::strftime(buffer, 100, "%Y.%m.%d.%H.%M.%S.", std::localtime(&t)))) {
      buffer[end]     = '0' + (microseconds / 100000 % 10);
      buffer[end + 1] = '0' + (microseconds / 10000 % 10);
      buffer[end + 2] = '0' + (microseconds / 1000 % 10);
      buffer[end + 3] = '0' + (microseconds / 100 % 10);
      buffer[end + 4] = '0' + (microseconds / 10 % 10);
      buffer[end + 5] = '0' + (microseconds % 10);
      buffer[end + 6] = '\0';
    }
    return buffer;
  }

get_millisecond_timestamp()

static std::string nimble::quanta::stopwatch::get_millisecond_timestamp ( )

inlinestatic

  {
    auto epoch_duration      = std::chrono::high_resolution_clock::now().time_since_epoch();
    auto duration_in_seconds = std::chrono::duration_cast<std::chrono::seconds>(epoch_duration);
    auto milliseconds =
        (std::chrono::duration_cast<std::chrono::milliseconds>(epoch_duration - duration_in_seconds).count());
    std::time_t t = duration_in_seconds.count();
    char        buffer[100]{};
    size_t      end;
    if ((end = std::strftime(buffer, 100, "%Y.%m.%e.%H.%M.%S.", std::localtime(&t)))) {
      size_t milliseconds = (std::chrono::duration_cast<std::chrono::milliseconds>(
                                 std::chrono::high_resolution_clock::now().time_since_epoch())
                                 .count());
      buffer[end]         = '0' + (milliseconds / 100 % 10);
      buffer[end + 1]     = '0' + (milliseconds / 10 % 10);
      buffer[end + 2]     = '0' + (milliseconds % 10);
      buffer[end + 3]     = '\0';
    }
    return buffer;
  }

get_nanosecond_timestamp()

static std::string nimble::quanta::stopwatch::get_nanosecond_timestamp ( )

inlinestatic

  {
    auto epoch_duration      = std::chrono::high_resolution_clock::now().time_since_epoch();
    auto duration_in_seconds = std::chrono::duration_cast<std::chrono::seconds>(epoch_duration);
    auto nanoseconds =
        (std::chrono::duration_cast<std::chrono::nanoseconds>(epoch_duration - duration_in_seconds).count());
    std::time_t t = duration_in_seconds.count();
    char        buffer[100]{};
    size_t      end;
    if ((end = std::strftime(buffer, 100, "%Y.%m.%e.%H.%M.%S.", std::localtime(&t)))) {
      buffer[end]     = '0' + (nanoseconds / 100000000 % 10);
      buffer[end + 1] = '0' + (nanoseconds / 10000000 % 10);
      buffer[end + 2] = '0' + (nanoseconds / 1000000 % 10);
      buffer[end + 3] = '0' + (nanoseconds / 100000 % 10);
      buffer[end + 4] = '0' + (nanoseconds / 10000 % 10);
      buffer[end + 5] = '0' + (nanoseconds / 1000 % 10);
      buffer[end + 6] = '0' + (nanoseconds / 100 % 10);
      buffer[end + 7] = '0' + (nanoseconds / 10 % 10);
      buffer[end + 8] = '0' + (nanoseconds % 10);
      buffer[end + 9] = '\0';
    }
    return buffer;
  }

reset()

void nimble::quanta::stopwatch::reset ( )

inline

  {
    _start = std::chrono::high_resolution_clock::now();
  }

timefunction()

template<class Function, class... Args>

static double nimble::quanta::stopwatch::timefunction ( Function && f, Args &&... inputs )

inlinestatic

  {
    stopwatch s;
    s.reset();
    f(std::forward<Args>(inputs)...);
    return s.age();
  }

Member Data Documentation

_start

time nimble::quanta::stopwatch::_start = std::chrono::high_resolution_clock::now()

---

The documentation for this struct was generated from the following file:

• src/nimble.quanta.stopwatch.h