stop_watch.hpp

#pragma once
 
#include <algorithm>
#include <exception>
#include <memory>
#include <new>
#include <system_error>
#include <utility>
#include <cmath>
 
#include "../_cexports/c_utilities.h"
 
#include "../global.hpp"
 
 
 
#include "utilities.hpp"
#include "system_info.hpp"
 
namespace Cvb
{
 
CVB_BEGIN_INLINE_NS
 
template <>
inline HandleGuard<Utilities::StopWatch>::HandleGuard(void * handle) noexcept
  : HandleGuard<Utilities::StopWatch>(handle, [](void* handle) { CVB_CALL_CAPI(TWDestroy(handle)); })
{
}
 
namespace Utilities
{
 
 
 
 
class StopWatch
{
 
  public:
 
 
    static std::unique_ptr<StopWatch> Create(StopWatchMode mode = StopWatchMode::MultiCPU)
    {
      auto stopWatch = Internal::DoBoolCallObjectOut<StopWatch>([&](void* & handle)
      {
        switch (mode)
        {
          default:
          case StopWatchMode::MultiCPU:
            return CVB_CALL_CAPI(TWCreateEx(&handle));
 
          case StopWatchMode::SingleCPU:
            return CVB_CALL_CAPI(TWCreate(&handle));
        }
 
      }, mode);
      stopWatch->Start();
      return stopWatch;
    }
 
 
    explicit StopWatch(StopWatchMode mode = StopWatchMode::MultiCPU)
      : StopWatch(std::move(*Create(mode)))
    {
    }
 
    
    StopWatch(const StopWatch& other) = delete;
    StopWatch& operator=(const StopWatch& other) = delete;
    StopWatch(StopWatch&& other) noexcept = default;
    StopWatch& operator=(StopWatch&& other) noexcept = default;
    ~StopWatch() = default;
 
 
    void* Handle() const noexcept
    {
      return handle_.Handle();
    }
 
 
 
    static std::unique_ptr<StopWatch> FromHandle(HandleGuard<StopWatch>&& guard, StopWatchMode mode)
    {
      if (!guard.Handle())
        throw std::runtime_error("handle must not be null");
 
      return std::unique_ptr<StopWatch>(new StopWatch(std::move(guard), mode));
    }
 
 
 
    void Start()
    {
      if(!CVB_CALL_CAPI(TWStartStopWatch(Handle(), static_cast<short>(0))))
        SystemInfo::ThrowLastError();
    }
 
 
    std::chrono::milliseconds TimeSpan() const
    {
      double value = std::numeric_limits<double>::quiet_NaN();
      if(!CVB_CALL_CAPI(TWReadStopWatch(Handle(), static_cast<short>(0), &value)))
        SystemInfo::ThrowLastError();
      return std::chrono::milliseconds(static_cast<std::size_t>(round(value)));
    }
 
 
    StopWatchMode Mode() const noexcept
    {
      return mode_;
    }
 
 
 
  private:
 
    StopWatch(HandleGuard<StopWatch>&& guard, StopWatchMode mode) noexcept
      : handle_(std::move(guard))
      , mode_(mode)
    {
    }
 
    HandleGuard<StopWatch> handle_;
 
 
    StopWatchMode mode_ = StopWatchMode::MultiCPU;
};
 
}
 
using Utilities::StopWatch;
 
CVB_END_INLINE_NS
 
}