////////////////////////////////////////////////////////////////////////////// // // (C) Copyright David Abrahams, Vicente Botet, Ion Gaztanaga 2009. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/move for documentation. // ////////////////////////////////////////////////////////////////////////////// // // Parts of this file come from Adobe's Move library: // // Copyright 2005-2007 Adobe Systems Incorporated // Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt // or a copy at http://stlab.adobe.com/licenses.html) // ////////////////////////////////////////////////////////////////////////////// //! \file #ifndef BOOST_MOVE_HPP #define BOOST_MOVE_HPP #include #include //copy, copy_backward #include //uninitialized_copy #include //std::iterator #include #include namespace boost { namespace move_detail { template struct identity { typedef T type; }; template struct is_convertible { typedef char true_t; class false_t { char dummy[2]; }; private: static true_t dispatch(U); static false_t dispatch(...); static T trigger(); public: enum { value = sizeof(dispatch(trigger())) == sizeof(true_t) }; typedef typename mpl::if_c::type type; }; } //namespace move_detail { } //namespace boost { #if !defined(BOOST_HAS_RVALUE_REFS) && !defined(BOOST_MOVE_DOXYGEN_INVOKED) namespace boost { ////////////////////////////////////////////////////////////////////////////// // // struct rv // ////////////////////////////////////////////////////////////////////////////// template class rv : public T { rv(); ~rv(); rv(rv const&); void operator=(rv const&); public: T &get() { return *this; } }; ////////////////////////////////////////////////////////////////////////////// // // move_detail::is_rv // ////////////////////////////////////////////////////////////////////////////// namespace move_detail { template struct is_rv { static const bool value = false; }; template struct is_rv< rv > { static const bool value = true; }; } //namespace move_detail { ////////////////////////////////////////////////////////////////////////////// // // is_movable // ////////////////////////////////////////////////////////////////////////////// template class is_movable { public: static const bool value = move_detail::is_convertible&>::value; }; template class is_movable< rv > { public: static const bool value = false; }; ////////////////////////////////////////////////////////////////////////////// // // move() // ////////////////////////////////////////////////////////////////////////////// #ifndef BOOST_NO_SFINAE template inline typename boost::disable_if, T&>::type move(T& x) { return x; } template inline typename enable_if, rv&>::type move(T& x) { return static_cast& >(x); } template inline typename enable_if, rv&>::type move(const rv& x) { return const_cast& >(x); } #else //BOOST_NO_SFINAE namespace move_detail { struct is_not_movable_tag { }; struct is_movable_tag { }; template inline T& move(T& x, is_not_movable_tag) { return x; } template inline rv& move(T& x, is_movable_tag) { return static_cast& >(x); } } // namespace move_detail { template inline typename mpl::if_c::value, rv & , T &>::type move(T &x) { typedef typename mpl::if_c::value, move_detail::is_movable_tag, move_detail::is_not_movable_tag>::type tag_type; return move_detail::move(x, tag_type()); } template inline rv & move(const rv & x) { BOOST_MPL_ASSERT(is_movable::value); return const_cast &>(x); } #endif ////////////////////////////////////////////////////////////////////////////// // // forward_constructor() // ////////////////////////////////////////////////////////////////////////////// #ifndef BOOST_NO_SFINAE template inline typename enable_if, T &>::type forward_constructor(const typename move_detail::identity::type &x) { return const_cast(x); } template inline typename disable_if, const T &>::type forward_constructor(const typename move_detail::identity::type &x) { return x; } #else // BOOST_NO_SFINAE namespace move_detail { struct is_not_rv_tag { }; struct is_rv_tag { }; template inline const T & forward_constructor(const typename move_detail::identity::type & x, is_not_rv_tag) { return x; } template inline T & forward_constructor(const typename move_detail::identity::type &x, is_rv_tag) { return const_cast(x); } } // namespace move_detail { template inline typename mpl::if_, T &, const T &>::type forward_constructor(const typename move_detail::identity::type &x) { typedef typename mpl::if_, move_detail::is_rv_tag, move_detail::is_not_rv_tag>::type tag_type; return move_detail::forward_constructor(x, tag_type()); } #endif ////////////////////////////////////////////////////////////////////////////// // // BOOST_ENABLE_MOVE_EMULATION // ////////////////////////////////////////////////////////////////////////////// #define BOOST_ENABLE_MOVE_EMULATION(TYPE)\ operator boost::rv&() \ { return static_cast& >(*this); }\ // #define BOOST_RV_REF(TYPE)\ boost::rv& \ // #define BOOST_CONSTRUCT_FWD_REF(TYPE)\ const TYPE & \ // } //namespace boost #else //BOOST_HAS_RVALUE_REFS #include namespace boost { ////////////////////////////////////////////////////////////////////////////// // // is_movable // ////////////////////////////////////////////////////////////////////////////// //! For compilers with rvalue references, this traits class returns true //! if T && is convertible to T. //! //! For other compilers returns true if T is convertible to boost::rv& template class is_movable { public: static const bool value = move_detail::is_convertible::value; }; ////////////////////////////////////////////////////////////////////////////// // // move // ////////////////////////////////////////////////////////////////////////////// #if defined(BOOST_MOVE_DOXYGEN_INVOKED) //! This function provides a way to convert a reference into a rvalue reference //! in compilers with rvalue reference. For other compilers converts T & into //! boost::rv & so that move emulation is activated. template inline rvalue_reference move (input_reference); #else template inline typename remove_reference::type&& move(T&& t) { return t; } #endif ////////////////////////////////////////////////////////////////////////////// // // forward_constructor // ////////////////////////////////////////////////////////////////////////////// #if defined(BOOST_MOVE_DOXYGEN_INVOKED) //! This function provides limited form of forwarding that is usually enough for //! in-place construction and avoids the exponential overloading necessary for //! perfect forwarding in C++03. //! //! For compilers with rvalue references this function provides perfect forwarding. //! //! Otherwise: //! * If input_reference binds to const boost::rv & then it output_reference is //! boost::rev & //! //! * Else, input_reference is equal to output_reference is equal to input_reference. template inline output_reference forward_constructor(input_reference); #else template inline T&& forward_constructor (typename move_detail::identity::type&& t) { return t; } #endif ////////////////////////////////////////////////////////////////////////////// // // BOOST_ENABLE_MOVE_EMULATION // ////////////////////////////////////////////////////////////////////////////// //! This macro expands to nothing for compilers with rvalue references. //! Otherwise expands to: //! \code //! operator boost::rv&() //! { return static_cast& >(*this); } //! \endcode #define BOOST_ENABLE_MOVE_EMULATION(TYPE)\ // //! This macro expands to T&& for compilers with rvalue references. //! Otherwise expands to boost::rv &. #define BOOST_RV_REF(TYPE)\ TYPE && \ // //! This macro expands to T&& for compilers with rvalue references. //! Otherwise expands to const T &. #define BOOST_CONSTRUCT_FWD_REF(TYPE)\ TYPE && \ // } //namespace boost { #endif //BOOST_HAS_RVALUE_REFS namespace boost { ////////////////////////////////////////////////////////////////////////////// // // move_iterator // ////////////////////////////////////////////////////////////////////////////// //! Class template move_iterator is an iterator adaptor with the same behavior //! as the underlying iterator except that its dereference operator implicitly //! converts the value returned by the underlying iterator's dereference operator //! to an rvalue reference. Some generic algorithms can be called with move //! iterators to replace copying with moving. template class move_iterator { public: typedef It iterator_type; typedef typename std::iterator_traits::value_type value_type; #if defined(BOOST_HAS_RVALUE_REFS) || defined(BOOST_MOVE_DOXYGEN_INVOKED) typedef value_type && reference; #else typedef typename boost::mpl::if_ < boost::is_movable , boost::rv& , value_type & >::type reference; #endif typedef typename std::iterator_traits::pointer pointer; typedef typename std::iterator_traits::difference_type difference_type; typedef typename std::iterator_traits::iterator_category iterator_category; move_iterator() {} explicit move_iterator(It i) : m_it(i) {} template move_iterator(const move_iterator& u) : m_it(u.base()) {} iterator_type base() const { return m_it; } reference operator*() const { #if defined(BOOST_HAS_RVALUE_REFS) return *m_it; #else return boost::move(*m_it); #endif } pointer operator->() const { return m_it; } move_iterator& operator++() { ++m_it; return *this; } move_iterator operator++(int) { move_iterator tmp(*this); ++(*this); return tmp; } move_iterator& operator--() { --m_it; return *this; } move_iterator operator--(int) { move_iterator tmp(*this); --(*this); return tmp; } move_iterator operator+ (difference_type n) const { return move_iterator(m_it + n); } move_iterator& operator+=(difference_type n) { m_it += n; return *this; } move_iterator operator- (difference_type n) const { return move_iterator(m_it - n); } move_iterator& operator-=(difference_type n) { m_it -= n; return *this; } reference operator[](difference_type n) const { #if defined(BOOST_HAS_RVALUE_REFS) return m_it[n]; #else return boost::move(m_it[n]); #endif } friend bool operator==(const move_iterator& x, const move_iterator& y) { return x.base() == y.base(); } friend bool operator!=(const move_iterator& x, const move_iterator& y) { return x.base() != y.base(); } friend bool operator< (const move_iterator& x, const move_iterator& y) { return x.base() < y.base(); } friend bool operator<=(const move_iterator& x, const move_iterator& y) { return x.base() <= y.base(); } friend bool operator> (const move_iterator& x, const move_iterator& y) { return x.base() > y.base(); } friend bool operator>=(const move_iterator& x, const move_iterator& y) { return x.base() >= y.base(); } friend difference_type operator-(const move_iterator& x, const move_iterator& y) { return x.base() - y.base(); } friend move_iterator operator+(difference_type n, const move_iterator& x) { return move_iterator(x.base() + n); } private: It m_it; }; //is_move_iterator namespace move_detail { template struct is_move_iterator { static const bool value = false; }; template struct is_move_iterator< ::boost::move_iterator > { static const bool value = true; }; } //namespace move_detail { ////////////////////////////////////////////////////////////////////////////// // // move_iterator // ////////////////////////////////////////////////////////////////////////////// //! //! Returns: move_iterator(i). template move_iterator make_move_iterator(const It &it) { return move_iterator(it); } ////////////////////////////////////////////////////////////////////////////// // // back_move_insert_iterator // ////////////////////////////////////////////////////////////////////////////// //! A move insert iterator that move constructs elements at the //! back of a container template // C models Container class back_move_insert_iterator : public std::iterator { C* container_m; public: typedef C container_type; explicit back_move_insert_iterator(C& x) : container_m(&x) { } back_move_insert_iterator& operator=(typename C::reference x) { container_m->push_back(boost::move(x)); return *this; } back_move_insert_iterator& operator*() { return *this; } back_move_insert_iterator& operator++() { return *this; } back_move_insert_iterator& operator++(int) { return *this; } }; //! //! Returns: back_move_insert_iterator(x). template // C models Container inline back_move_insert_iterator back_move_inserter(C& x) { return back_move_insert_iterator(x); } ////////////////////////////////////////////////////////////////////////////// // // front_move_insert_iterator // ////////////////////////////////////////////////////////////////////////////// //! A move insert iterator that move constructs elements int the //! front of a container template // C models Container class front_move_insert_iterator : public std::iterator { C* container_m; public: typedef C container_type; explicit front_move_insert_iterator(C& x) : container_m(&x) { } front_move_insert_iterator& operator=(typename C::reference x) { container_m->push_front(boost::move(x)); return *this; } front_move_insert_iterator& operator*() { return *this; } front_move_insert_iterator& operator++() { return *this; } front_move_insert_iterator& operator++(int) { return *this; } }; //! //! Returns: front_move_insert_iterator(x). template // C models Container inline front_move_insert_iterator front_move_inserter(C& x) { return front_move_insert_iterator(x); } ////////////////////////////////////////////////////////////////////////////// // // insert_move_iterator // ////////////////////////////////////////////////////////////////////////////// template // C models Container class move_insert_iterator : public std::iterator { C* container_m; typename C::iterator pos_; public: typedef C container_type; explicit move_insert_iterator(C& x, typename C::iterator pos) : container_m(&x), pos_(pos) {} move_insert_iterator& operator=(typename C::reference x) { pos_ = container_m->insert(pos_, boost::move(x)); ++pos_; return *this; } move_insert_iterator& operator*() { return *this; } move_insert_iterator& operator++() { return *this; } move_insert_iterator& operator++(int) { return *this; } }; //! //! Returns: move_insert_iterator(x, it). template // C models Container inline move_insert_iterator move_inserter(C& x, typename C::iterator it) { return move_insert_iterator(x, it); } ////////////////////////////////////////////////////////////////////////////// // // move // ////////////////////////////////////////////////////////////////////////////// //! Effects: Moves elements in the range [first,last) into the range [result,result + (last - //! first)) starting from first and proceeding to last. For each non-negative integer n < (last-first), //! performs *(result + n) = boost::move (*(first + n)). //! //! Effects: result + (last - first). //! //! Requires: result shall not be in the range [first,last). //! //! Complexity: Exactly last - first move assignments. template // O models OutputIterator O move(I f, I l, O result) { while (f != l) { *result = boost::move(*f); ++f; ++result; } return result; } ////////////////////////////////////////////////////////////////////////////// // // move_backward // ////////////////////////////////////////////////////////////////////////////// //! Effects: Moves elements in the range [first,last) into the range //! [result - (last-first),result) starting from last - 1 and proceeding to //! first. For each positive integer n <= (last - first), //! performs *(result - n) = boost::move(*(last - n)). //! //! Requires: result shall not be in the range [first,last). //! //! Returns: result - (last - first). //! //! Complexity: Exactly last - first assignments. template // O models BidirectionalIterator O move_backward(I f, I l, O result) { while (f != l) { --l; --result; *result = boost::move(*l); } return result; } ////////////////////////////////////////////////////////////////////////////// // // uninitialized_move // ////////////////////////////////////////////////////////////////////////////// //! Effects: //! \code //! for (; first != last; ++result, ++first) //! new (static_cast(&*result)) //! typename iterator_traits::value_type(boost::move(*first)); //! \endcode //! //! Returns: result template // F models ForwardIterator F uninitialized_move(I f, I l, F r /// @cond ,typename enable_if::value_type> >::type* = 0 /// @endcond ) { typedef typename std::iterator_traits::value_type input_value_type; while (f != l) { ::new(static_cast(&*r)) input_value_type(boost::move(*f)); ++f; ++r; } return r; } /// @cond template // F models ForwardIterator F uninitialized_move(I f, I l, F r, typename disable_if::value_type> >::type* = 0) { return std::uninitialized_copy(f, l, r); } ////////////////////////////////////////////////////////////////////////////// // // uninitialized_copy_or_move // ////////////////////////////////////////////////////////////////////////////// namespace move_detail { template // F models ForwardIterator F uninitialized_move_move_iterator(I f, I l, F r, typename enable_if< is_movable >::type* = 0) { return boost::uninitialized_move(f, l, r); } template // F models ForwardIterator F uninitialized_move_move_iterator(I f, I l, F r, typename disable_if< is_movable >::type* = 0) { return std::uninitialized_copy(f.base(), l.base(), r); } } //namespace move_detail { template // F models ForwardIterator F uninitialized_copy_or_move(I f, I l, F r, typename enable_if< move_detail::is_move_iterator >::type* = 0) { return boost::move_detail::uninitialized_move_move_iterator(f, l, r); } /// @endcond //! Effects: //! \code //! for (; first != last; ++result, ++first) //! new (static_cast(&*result)) //! typename iterator_traits::value_type(*first); //! \endcode //! //! Returns: result //! //! Note: This function is provided because //! std::uninitialized_copy from some STL implementations //! is not compatible with move_iterator template // F models ForwardIterator F uninitialized_copy_or_move(I f, I l, F r /// @cond ,typename disable_if< move_detail::is_move_iterator >::type* = 0 /// @endcond ) { return std::uninitialized_copy(f, l, r); } } //namespace boost { #endif //#ifndef BOOST_MOVE_HPP