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;
      }
      static std::unique_ptr<StopWatch> Create(StopWatchMode mode = StopWatchMode::MultiCPU) {…}


      explicit StopWatch(StopWatchMode mode = StopWatchMode::MultiCPU)
          : StopWatch(std::move(*Create(mode)))
      {
      }
      explicit StopWatch(StopWatchMode mode = StopWatchMode::MultiCPU) {…}
 
      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();
      }
      void *Handle() const noexcept {…}


      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));
      }
      static std::unique_ptr<StopWatch> FromHandle(HandleGuard<StopWatch> &&guard, StopWatchMode mode) {…}


      void Start()
      {
        if (!CVB_CALL_CAPI(TWStartStopWatch(Handle(), static_cast<short>(0))))
          SystemInfo::ThrowLastError();
      }
      void Start() {…}


      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)));
      }
      std::chrono::milliseconds TimeSpan() const {…}


      StopWatchMode Mode() const noexcept
      {
        return mode_;
      }
      StopWatchMode Mode() const noexcept {…}
 
    private:
      StopWatch(HandleGuard<StopWatch> &&guard, StopWatchMode mode) noexcept
          : handle_(std::move(guard))
          , mode_(mode)
      {
      }
 
      HandleGuard<StopWatch> handle_;
 
      StopWatchMode mode_ = StopWatchMode::MultiCPU;
    };
    class StopWatch {…};
 
  }  // namespace Utilities
 
  using Utilities::StopWatch;
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb