//
// (C) Copyright Thomas Klimpel 2010.
// 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)
//
#ifndef BOOST_OPTIMIZED_MOVE_WRAPPER_HPP
#define BOOST_OPTIMIZED_MOVE_WRAPPER_HPP
#include <boost/move/move.hpp>

#if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED)

namespace boost {

// A wrapper class to fix the signature of the copy assignment operator
// of a copyable and movable class using the optimized move emulation.
template <class OptimizedCopyAndMove>
class optimized_move_wrapper : public OptimizedCopyAndMove
{
  typedef OptimizedCopyAndMove base_t;
public:
  // mark this type as movable, and provide the required conversion operators
  operator ::BOOST_MOVE_NAMESPACE::rv<optimized_move_wrapper>&()
  {  return *reinterpret_cast< ::BOOST_MOVE_NAMESPACE::rv<optimized_move_wrapper>* >(this);  }
  operator const ::BOOST_MOVE_NAMESPACE::rv<optimized_move_wrapper>&() const
  {  return *reinterpret_cast<const ::BOOST_MOVE_NAMESPACE::rv<optimized_move_wrapper>* >(this);  }

  // copy constructor
  optimized_move_wrapper(const optimized_move_wrapper& w) : base_t(w) {}
  // move constructor
  optimized_move_wrapper(BOOST_RV_REF(optimized_move_wrapper) w) : base_t(boost::move(static_cast<base_t&>(w))) {}

  // copy assignment operator with nice signature, using RVO for move assignment of temporaries
  optimized_move_wrapper& operator=(optimized_move_wrapper s) { base_t::operator=(boost::move(static_cast<base_t&>(s))); return *this; }
  // move assignment operator
  optimized_move_wrapper& operator=(BOOST_RV_REF(optimized_move_wrapper) b) { base_t::operator=(boost::move(static_cast<base_t&>(b))); return *this; }

  //optimized_move_wrapper(base_t& b) : base_t(b) {}
  //optimized_move_wrapper(BOOST_RV_REF(base_t) b) : base_t(b) {}
  //optimized_move_wrapper(const BOOST_RV_REF(base_t) b) : base_t(b) {}

  // forward constructor with no arguments
  optimized_move_wrapper() {}
  // forward constructors with 1 argument
  template<class MaybeRv>
  explicit optimized_move_wrapper(BOOST_FWD_REF(MaybeRv) a)
    : base_t(boost::forward<MaybeRv>(a)) {}
  // forward constructors with 2 arguments
  template<class MaybeRv1, class MaybeRv2>
  optimized_move_wrapper(BOOST_FWD_REF(MaybeRv1) a1, BOOST_FWD_REF(MaybeRv2) a2)
    : base_t(boost::forward<MaybeRv1>(a1), boost::forward<MaybeRv2>(a2)) {}
  // forward constructors with 3 arguments
  template<class MaybeRv1, class MaybeRv2, class MaybeRv3>
  optimized_move_wrapper(BOOST_FWD_REF(MaybeRv1) a1, BOOST_FWD_REF(MaybeRv2) a2, BOOST_FWD_REF(MaybeRv3) a3)
    : base_t(boost::forward<MaybeRv1>(a1), boost::forward<MaybeRv2>(a2), boost::forward<MaybeRv2>(a3)) {}

  // forward copy and move assignment operators
  optimized_move_wrapper& operator=(base_t& b) { base_t::operator=(b); return *this; }
  optimized_move_wrapper& operator=(BOOST_RV_REF(base_t) b) { base_t::operator=(b); return *this; }
  optimized_move_wrapper& operator=(const BOOST_RV_REF(base_t) b) { base_t::operator=(b); return *this; }

  // forward other assignment operators
  template<class MaybeRv>
  optimized_move_wrapper& operator=(BOOST_FWD_REF(MaybeRv) a)
  { base_t::operator=(boost::forward<MaybeRv>(a)); return *this; }
};
}  // namespace boost

#define BOOST_OPTIMIZED_MOVE_WRAPPER(TYPE)\
  boost::optimized_move_wrapper<TYPE>\
//

#else  //BOOST_NO_RVALUE_REFERENCES

#define BOOST_OPTIMIZED_MOVE_WRAPPER(TYPE)\
  TYPE\
//

#endif
#endif