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;
    }


    StopWatch(StopWatchMode mode = StopWatchMode::MultiCPU)
      : StopWatch(std::move(*Create(mode)))
    {
    }


    StopWatch(StopWatch&& other) noexcept = default;


    StopWatch& operator=(StopWatch&& other) noexcept = 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

}