Add a thread wrapper class that interrupts and join on destruction

[viboes]

Based on the scoped_thread class defined in C++ Concurrency in Action define a thread wrapper class that instead of calling terminate if the thread is joinable on destruction, interrupts and join it if joinable.

While the scoped_thread class defined in C++ Concurrency in Action is a strict scoped class that doesn't allows any change in the wrapped thread, I think that making the interface thread compatible is also a good option. This doesn't means that a strict scoped thread has no use.

namespace boost
{
  class scoped_thread
  {
    thread t;
  public:
    BOOST_THREAD_NO_COPYABLE( scoped_thread)
    explicit scoped_thread(BOOST_THREAD_RV_REF(thread) t_) :
      t(move(t_))
    {
    }
    inline thread::id get_id() const BOOST_NOEXCEPT
    {
      return t.get_id();
    }
    void swap(scoped_thread& x)BOOST_NOEXCEPT
    {
      t.swap(x.t);
    }
    void detach()
    {
      t.detach();
    }
    void join()
    {
      t.join();
    }
    template <class Rep, class Period>
    bool try_join_for(const chrono::duration<Rep, Period>& rel_time)
    {
      return t.try_join_for(rel_time);
    }
    template <class Clock, class Duration>
    bool try_join_until(const chrono::time_point<Clock, Duration>& abs_time)
    {
      return t.try_join_until(abs_time);
    }
    thread::native_handle_type native_handle() BOOST_NOEXCEPT {
      return t.native_handle();
    }
    void interrupt()
    {
      t.interrupt();
    }

    bool interruption_requested() const BOOST_NOEXCEPT
    {
      return t.interruption_requested();
    }
    ~scoped_thread()
    {
      t.interrupt();
      if (t.joinable())
      {
        t.join();
      }
    }
  };
  inline void swap(scoped_thread& lhs,scoped_thread& rhs) BOOST_NOEXCEPT
  {
      return lhs.swap(rhs);
  }
}