Boost C++ Libraries

Next follows the interface of the legacy move semantic helper class and function.

namespace boost
{
  namespace detail
  {
      template<typename T>
      struct thread_move_t
      {
        explicit thread_move_t(T& t_);
        T& operator*() const;
        T* operator->() const;
      private:
        void operator=(thread_move_t&);
      };
  }
  template<typename T>
  boost::detail::thread_move_t<T> move(boost::detail::thread_move_t<T> t);
}

We can write a MovableOny class as follows. You just need to follow these simple steps:

For example the thread class defines the following:

class thread
{
  // ...
private:
    thread(thread&);
    thread& operator=(thread&);
public:
    detail::thread_move_t<thread> move()
    {
        detail::thread_move_t<thread> x(*this);
        return x;
    }
    operator detail::thread_move_t<thread>()
    {
        return move();
    }
    thread(detail::thread_move_t<thread> x)
    {
        thread_info=x->thread_info;
        x->thread_info.reset();
    }
    thread& operator=(detail::thread_move_t<thread> x)
    {
        thread new_thread(x);
        swap(new_thread);
        return *this;
    }
  // ...

};

This macro marks a class as no copyable, disabling copy construction and assignment.

This macro marks a class as movable, declaring all the implicit conversions to an rvalue-reference.

This macro marks a type as movable but not copyable, disabling copy construction and assignment. The user will need to write a move constructor/assignment to fully write a movable but not copyable class.

This macro marks a type as copyable and movable. The user will need to write a move constructor/assignment and a copy assignment to fully write a copyable and movable class.

This macro is used to achieve portable syntax in move constructors and assignments for classes marked as BOOST_THREAD_COPYABLE_AND_MOVABLE or BOOST_THREAD_MOVABLE_ONLY.

BOOST_THREAD_RV_REF_BEG and BOOST_THREAD_RV_REF_END are used when the parameter end with a > to avoid the compiler error.

While Boost.Move emulation allows to access an rvalue reference BOOST_THREAD_RV_REF(TYPE) using the dot operator, the legacy defines the operator->. We need then a macro BOOST_THREAD_RV that mask this difference. E.g.

thread(BOOST_THREAD_RV_REF(thread) x)
{
    thread_info=BOOST_THREAD_RV(x).thread_info;
    BOOST_THREAD_RV(x).thread_info.reset();
}

The use of this macros has reduced considerably the size of the Boost.Thread move related code.

While Boost.Move is the best C++03 move emulation there are some limitations that impact the way the library can be used. For example, with the following declarations

class thread {
  // ...
private:
  thread(thread &);
public:
  thread(rv<thread>&);
  // ...
};

This could not work on some compilers even if thread is convertible to rv<thread> because the compiler prefers the private copy constructor.

thread mkth()
{
  return thread(f);
}

On these compilers we need to use instead an explicit conversion. The library provides a move member function that allows to workaround the issue.

thread mkth()
{
  return thread(f).move();
}

Note that ::boost::move can not be used in this case as thread is not implicitly convertible to thread&.

thread mkth()
{
  return ::boost::move(thread(f));
}

To make the code portable Boost.Thread the user needs to use a macro BOOST_THREAD_MAKE_RV_REF that can be used as in

thread mkth()
{
  return BOOST_THREAD_MAKE_RV_REF(thread(f));
}

Note that this limitation is shared also by the legacy Boost.Thread move emulation.

As Boost.Move defines also the boost::move function we need to specialize the has_move_emulation_enabled_aux metafunction.

template <>
struct has_move_emulation_enabled_aux<thread>
  : BOOST_MOVE_BOOST_NS::integral_constant<bool, true>
{};

so that the following Boost.Move overload is disabled

template <class T>
inline typename BOOST_MOVE_BOOST_NS::disable_if<has_move_emulation_enabled_aux<T>, T&>::type move(T& x);

The macros BOOST_THREAD_DCL_MOVABLE(CLASS), BOOST_THREAD_DCL_MOVABLE_BEG(T1) and BOOST_THREAD_DCL_MOVABLE_END are used for this purpose. E.g.

BOOST_THREAD_DCL_MOVABLE(thread)

and

BOOST_THREAD_DCL_MOVABLE_BEG(T) promise<T> BOOST_THREAD_DCL_MOVABLE_END