Class Thread

libs/base/thread.hpp:27–67

A wrapper for system threads API. Thread class manages lifetime of a running IRoutine and guarantees that it will be possible to access the IRoutine after Thread::Create() call until cancellation or destruction. In the latter case, system thread will be responsible for deletion of a IRoutine.

/// latter case, system thread will be responsible for deletion of a
/// IRoutine.
class Thread
{
  std::thread m_thread;
  std::shared_ptr<IRoutine> m_routine;

  DISALLOW_COPY(Thread);

public:
  Thread();
  ~Thread();

  /// Run thread immediately.
  ///
  /// @param routine Routine that will be executed on m_thread and
  ///                destroyed by the current Thread instance or by
  ///                the m_thread, if it is detached during the
  ///                execution of routine.
  bool Create(std::unique_ptr<IRoutine> && routine);

  /// Calling the IRoutine::Cancel method, and Join'ing with the task
  /// execution.  After that, routine is deleted.
  void Cancel();

  /// Wait for thread ending.
  void Join();

  /// \return Pointer to the routine.
  IRoutine * GetRoutine();

  /// \return Pointer to the routine converted to T *.  When it's not
  ///         possible to convert routine to the T *, release version
  ///         returns nullptr, debug version fails.
  template <typename T>
  T * GetRoutineAs()
  {
    ASSERT(m_routine.get(), ("Routine is not set"));
    T * ptr = dynamic_cast<T *>(m_routine.get());
    ASSERT(ptr, ("Can't convert IRoutine* to", TO_STRING(T) "*"));
    return ptr;
  }
};

/// Suspends the execution of the current thread until the time-out interval elapses.
/// @param[in] ms time-out interval in milliseconds