thread.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2020 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 <string>
#include <system_error>
#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>
  Thread(Function&& func, Args&&... args);
  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;
 
  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;
 
  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>
inline 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(result);
}
 
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 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;
}
 
template <class Function, class... Args>
Error Thread::Start(Function&& func, Args&&... args)
{
  if (thread_)
    return kEtcPalErrInvalid;
 
  thread_.reset(new etcpal_thread_t);
 
  auto new_f = std::unique_ptr<FunctionType>(
      new FunctionType(std::bind(std::forward<Function>(func), std::forward<Args>(args)...)));
  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_)
  {
    Error join_res = etcpal_thread_timed_join(thread_.get(), timeout_ms);
    if (join_res)
      thread_.reset();
    return join_res;
  }
  else
  {
    return kEtcPalErrInvalid;
  }
}
 
inline Error Thread::Terminate() noexcept
{
  if (thread_)
  {
    Error terminate_res = etcpal_thread_terminate(thread_.get());
    if (terminate_res)
      thread_.reset();
    return terminate_res;
  }
  else
  {
    return kEtcPalErrInvalid;
  }
}
 
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_