thread.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2022 ETC Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *******************************************************************************
 * This file is a part of EtcPal. For more information, go to:
 * https://github.com/ETCLabs/EtcPal
 ******************************************************************************/
 
 
#ifndef ETCPAL_CPP_THREAD_H_
#define ETCPAL_CPP_THREAD_H_
 
#include <algorithm>
#include <cassert>
#include <chrono>
#include <functional>
#include <limits>
#include <memory>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <utility>
#include "etcpal/common.h"
#include "etcpal/thread.h"
#include "etcpal/cpp/common.h"
#include "etcpal/cpp/error.h"
 
namespace etcpal
{
 
class Thread
{
public:
  Thread() = default;
  template <class Function,
            class... Args,
            typename std::enable_if<!std::is_arithmetic<Function>::value, bool>::type = true>
  Thread(Function&& func, Args&&... args);
  Thread(unsigned int priority, unsigned int stack_size, const char* name, void* platform_data = nullptr);
  virtual ~Thread();
 
  Thread(Thread&& other) noexcept;
  Thread& operator=(Thread&& other) noexcept;
 
  Thread(const Thread& other) = delete;
  Thread& operator=(const Thread& other) = delete;
 
  bool joinable() const noexcept;
 
  unsigned int              priority() const noexcept;
  unsigned int              stack_size() const noexcept;
  const char*               name() const noexcept;
  void*                     platform_data() const noexcept;
  const EtcPalThreadParams& params() const noexcept;
  etcpal_thread_os_handle_t os_handle() const noexcept;
 
  Thread& SetPriority(unsigned int priority) noexcept;
  Thread& SetStackSize(unsigned int stack_size) noexcept;
  Thread& SetName(const char* name) noexcept;
  Thread& SetName(const std::string& name) noexcept;
  Thread& SetPlatformData(void* platform_data) noexcept;
  Thread& SetParams(const EtcPalThreadParams& params) noexcept;
 
  template <class Function, class... Args>
  Error Start(Function&& func, Args&&... args);
  Error Join(int timeout_ms = ETCPAL_WAIT_FOREVER) noexcept;
  Error Terminate() noexcept;
 
  static void Sleep(unsigned int ms) noexcept;
  template <typename Rep, typename Period>
  static void Sleep(const std::chrono::duration<Rep, Period>& sleep_duration) noexcept;
 
  using FunctionType = std::function<void()>;
 
private:
  std::unique_ptr<etcpal_thread_t> thread_;
  EtcPalThreadParams               params_{ETCPAL_THREAD_PARAMS_INIT_VALUES};
};
 
 
extern "C" inline void CppThreadFn(void* arg)
{
  std::unique_ptr<Thread::FunctionType> p_func(static_cast<Thread::FunctionType*>(arg));
  // Tear the roof off the sucker
  (*p_func)();
}
 
 
template <class Function, class... Args, typename std::enable_if<!std::is_arithmetic<Function>::value, bool>::type>
Thread::Thread(Function&& func, Args&&... args)
{
  ETCPAL_THREAD_SET_DEFAULT_PARAMS(&params_);
  auto result = Start(std::forward<Function>(func), std::forward<Args>(args)...);
  if (!result)
    ETCPAL_THROW(std::runtime_error("Error while starting EtcPal thread: " + result.ToString()));
}
 
inline Thread::Thread(unsigned int priority, unsigned int stack_size, const char* name, void* platform_data)
    : params_{priority, stack_size, name, platform_data}
{
}
 
inline Thread::~Thread()
{
  if (thread_)
    etcpal_thread_join(thread_.get());
}
 
inline Thread::Thread(Thread&& other) noexcept
{
  *this = std::move(other);
}
 
inline Thread& Thread::operator=(Thread&& other) noexcept
{
  thread_ = std::move(other.thread_);
  params_ = other.params_;
  ETCPAL_THREAD_SET_DEFAULT_PARAMS(&other.params_);
  return *this;
}
 
inline bool Thread::joinable() const noexcept
{
  return (bool)thread_;
}
 
inline unsigned int Thread::priority() const noexcept
{
  return params_.priority;
}
 
inline unsigned int Thread::stack_size() const noexcept
{
  return params_.stack_size;
}
 
inline const char* Thread::name() const noexcept
{
  return params_.thread_name;
}
 
inline void* Thread::platform_data() const noexcept
{
  return params_.platform_data;
}
 
inline const EtcPalThreadParams& Thread::params() const noexcept
{
  return params_;
}
 
inline etcpal_thread_os_handle_t Thread::os_handle() const noexcept
{
  return thread_ ? etcpal_thread_get_os_handle(thread_.get()) : ETCPAL_THREAD_OS_HANDLE_INVALID;
}
 
inline Thread& Thread::SetPriority(unsigned int priority) noexcept
{
  params_.priority = priority;
  return *this;
}
 
inline Thread& Thread::SetStackSize(unsigned int stack_size) noexcept
{
  params_.stack_size = stack_size;
  return *this;
}
 
inline Thread& Thread::SetName(const char* name) noexcept
{
  params_.thread_name = name;
  return *this;
}
 
inline Thread& Thread::SetName(const std::string& name) noexcept
{
  params_.thread_name = name.c_str();
  return *this;
}
 
inline Thread& Thread::SetPlatformData(void* platform_data) noexcept
{
  params_.platform_data = platform_data;
  return *this;
}
 
inline Thread& Thread::SetParams(const EtcPalThreadParams& params) noexcept
{
  params_ = params;
  return *this;
}
 
template <class Function, class... Args>
Error Thread::Start(Function&& func, Args&&... args)
{
  if (thread_)
    return kEtcPalErrInvalid;
 
  thread_ = std::unique_ptr<etcpal_thread_t>(new etcpal_thread_t);
  if (!thread_)
    return kEtcPalErrNoMem;
 
  // TODO evaluate changing bind to lambda
  auto new_f = std::unique_ptr<FunctionType>(new FunctionType(
      std::bind(std::forward<Function>(func), std::forward<Args>(args)...)));  // NOLINT(modernize-avoid-bind)
  if (!new_f)
    return kEtcPalErrNoMem;
 
  Error create_res = etcpal_thread_create(thread_.get(), &params_, CppThreadFn, new_f.get());
  if (create_res)
    new_f.release();
  else
    thread_.reset();
  return create_res;
}
 
inline Error Thread::Join(int timeout_ms) noexcept
{
  if (!thread_)
    return kEtcPalErrInvalid;
 
  Error join_res = etcpal_thread_timed_join(thread_.get(), timeout_ms);
  if (join_res)
    thread_.reset();
  return join_res;
}
 
inline Error Thread::Terminate() noexcept
{
  if (!thread_)
    return kEtcPalErrInvalid;
 
  Error terminate_res = etcpal_thread_terminate(thread_.get());
  if (terminate_res)
    thread_.reset();
  return terminate_res;
}
 
inline void Thread::Sleep(unsigned int ms) noexcept
{
  etcpal_thread_sleep(ms);
}
 
template <typename Rep, typename Period>
void Thread::Sleep(const std::chrono::duration<Rep, Period>& sleep_duration) noexcept
{
  // This implementation cannot sleep longer than UINT_MAX.
  unsigned int sleep_ms_clamped = static_cast<unsigned int>(
      std::min(std::chrono::milliseconds(sleep_duration).count(),
               static_cast<std::chrono::milliseconds::rep>(std::numeric_limits<unsigned int>::max())));
  Sleep(sleep_ms_clamped);
}
 
};  // namespace etcpal
 
#endif  // ETCPAL_CPP_THREAD_H_