timer.hpp

Go to the documentation of this file.

#pragma once
 
#include <chrono>
#include <string>
#include <vector>
 
#include <cpp-toolbox/cpp-toolbox_export.hpp>
 
namespace toolbox::utils
{
 
class CPP_TOOLBOX_EXPORT stop_watch_timer_t
{
public:
  stop_watch_timer_t(std::string name = "default_timer");
 
  void set_name(const std::string& name);
 
  auto get_name() const -> const std::string&;
 
  void start();
 
  void stop();
 
  void reset();
 
  auto elapsed_time_ms() const -> double;
 
  auto elapsed_time() const -> double;
 
  void print_stats() const;
 
private:
  std::string name_;  
  std::chrono::nanoseconds total_duration_;  
  std::chrono::time_point<std::chrono::high_resolution_clock>
      start_time_;  
  bool running_;  
};
 
class CPP_TOOLBOX_EXPORT simple_timer_interface_t
{
public:
  virtual ~simple_timer_interface_t() = default;
 
  virtual void start(int index) = 0;
 
  virtual void stop(int index) = 0;
 
  virtual void reset(int index) = 0;
 
  virtual void print_stats(int index) const = 0;
 
  virtual void print_all_stats() const = 0;
 
  virtual auto elapsed_time_ms(int index) const -> double = 0;
 
  virtual auto elapsed_time(int index) const -> double = 0;
 
  virtual auto size() const -> size_t = 0;
};
 
class CPP_TOOLBOX_EXPORT simple_timer_array_t : public simple_timer_interface_t
{
public:
  explicit simple_timer_array_t(int size);
 
  explicit simple_timer_array_t(const std::vector<std::string>& names);
 
  // Delete copy constructor and assignment operator
  simple_timer_array_t(const simple_timer_array_t&) = delete;
  auto operator=(const simple_timer_array_t&) -> simple_timer_array_t& = delete;
 
  // Allow move semantics
  simple_timer_array_t(simple_timer_array_t&&) = default;
  auto operator=(simple_timer_array_t&&) -> simple_timer_array_t& = default;
 
  ~simple_timer_array_t() override = default;
 
  // Implement interface methods
  void start(int index) override;
  void stop(int index) override;
  void reset(int index) override;
  auto elapsed_time_ms(int index) const -> double override;
  auto elapsed_time(int index) const -> double override;
  void print_stats(int index) const override;
  void print_all_stats() const override;
  auto size() const -> size_t override;
 
private:
  void check_id(int index) const;
 
  std::vector<stop_watch_timer_t> timers_;  
};
 
inline auto create_timer(simple_timer_interface_t** timer_interface, int size)
    -> bool
{
  *timer_interface =
      static_cast<simple_timer_interface_t*>(new simple_timer_array_t(size));
  return (*timer_interface != nullptr) ? true : false;
}
 
inline auto create_timer_with_names(simple_timer_interface_t** timer_interface,
                                    const std::vector<std::string>& names)
    -> bool
{
  *timer_interface = reinterpret_cast<simple_timer_interface_t*>(
      new simple_timer_array_t(names));
  return (*timer_interface != nullptr) ? true : false;
}
 
inline auto delete_timer(simple_timer_interface_t** timer_interface) -> bool
{
  if (*timer_interface != nullptr) {
    delete *timer_interface;
    *timer_interface = nullptr;
  }
  return true;
}
 
inline auto start_timer(simple_timer_interface_t** timer_interface, int id)
    -> bool
{
  if (*timer_interface != nullptr) {
    (*timer_interface)->start(id);
  }
  return true;
}
 
inline auto stop_timer(simple_timer_interface_t** timer_interface, int id)
    -> bool
{
  if (*timer_interface != nullptr) {
    (*timer_interface)->stop(id);
  }
  return true;
}
 
inline auto reset_timer(simple_timer_interface_t** timer_interface, int id)
    -> bool
{
  if (*timer_interface != nullptr) {
    (*timer_interface)->reset(id);
  }
  return true;
}
 
inline auto display_timer(simple_timer_interface_t** timer_interface, int id)
    -> bool
{
  if (*timer_interface != nullptr) {
    (*timer_interface)->print_stats(id);
  }
  return true;
}
 
inline auto display_all_timer(simple_timer_interface_t** timer_interface)
    -> bool
{
  if (*timer_interface != nullptr) {
    (*timer_interface)->print_all_stats();
  }
  return true;
}
 
inline auto get_timer_elapsed(simple_timer_interface_t** timer_interface,
                              int id) -> double
{
  if (*timer_interface != nullptr) {
    return (*timer_interface)->elapsed_time(id);
  }
  return 0.0;
}
 
inline auto get_timer_elapsed_ms(simple_timer_interface_t** timer_interface,
                                 int id) -> double
{
  if (*timer_interface != nullptr) {
    return (*timer_interface)->elapsed_time_ms(id);
  }
  return 0.0;
}
 
}  // namespace toolbox::utils