ceph/src/boost/libs/move/test/move.cpp

   1 //////////////////////////////////////////////////////////////////////////////
   2 //
   3 // (C) Copyright David Abrahams, Vicente Botet, Ion Gaztanaga 2009.
   4 // (C) Copyright Ion Gaztanaga 2009-2014.
   5 // Distributed under the Boost Software License, Version 1.0.
   6 // (See accompanying file LICENSE_1_0.txt or copy at
   7 // http://www.boost.org/LICENSE_1_0.txt)
   8 //
   9 // See http://www.boost.org/libs/move for documentation.
  10 //
  11 //////////////////////////////////////////////////////////////////////////////
  12 #include <boost/move/utility_core.hpp>
  13 #include <boost/core/ignore_unused.hpp>
  14 #include "../example/movable.hpp"
  15 #include "../example/copymovable.hpp"
  16 #include <boost/static_assert.hpp>
  17
  18 movable function(movable m)
  19 {
  20    return movable(boost::move(m));
  21 }
  22
  23 movable functionr(BOOST_RV_REF(movable) m)
  24 {
  25    return movable(boost::move(m));
  26 }
  27
  28 movable function2(movable m)
  29 {
  30    return boost::move(m);
  31 }
  32
  33 BOOST_RV_REF(movable) function2r(BOOST_RV_REF(movable) m)
  34 {
  35    return boost::move(m);
  36 }
  37
  38 movable move_return_function2 ()
  39 {
  40     return movable();
  41 }
  42
  43 movable move_return_function ()
  44 {
  45     movable m;
  46     return (boost::move(m));
  47 }
  48
  49
  50 //Catch by value
  51 void function_value(movable)
  52 {}
  53
  54 //Catch by reference
  55 void function_ref(const movable &)
  56 {}
  57
  58 //Catch by reference
  59 void function_ref(BOOST_RV_REF(movable))
  60 {}
  61
  62 movable create_movable()
  63 {  return movable(); }
  64
  65 template<class Type>
  66 struct factory
  67 {
  68    Type operator()() const
  69    {
  70       Type t;
  71       return BOOST_MOVE_RET(Type, t);
  72    }
  73 };
  74
  75 template<class Type>
  76 struct factory<Type &>
  77 {
  78    static Type t;
  79    Type &operator()() const
  80    {
  81       return BOOST_MOVE_RET(Type&, t);
  82    }
  83 };
  84
  85 template<class Type>
  86 Type factory<Type&>::t;
  87
  88 template <class R, class F>
  89 R factory_wrapper(F f)
  90 {
  91   // lock();
  92   R r = f();
  93   // unlock();
  94   return BOOST_MOVE_RET(R, r);
  95 }
  96
  97 int main()
  98 {
  99    #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 100    BOOST_STATIC_ASSERT((boost::has_nothrow_move<movable>::value == true));
 101    BOOST_STATIC_ASSERT((boost::has_move_emulation_enabled<copyable>::value == false));
 102    BOOST_STATIC_ASSERT((boost::has_move_emulation_enabled<copyable*>::value == false));
 103    BOOST_STATIC_ASSERT((boost::has_move_emulation_enabled<int>::value == false));
 104    BOOST_STATIC_ASSERT((boost::has_move_emulation_enabled<int&>::value == false));
 105    BOOST_STATIC_ASSERT((boost::has_move_emulation_enabled<int*>::value == false));
 106    #endif
 107
 108    {
 109       movable m;
 110       movable m2(boost::move(m));
 111       movable m3(function(movable(boost::move(m2))));
 112       movable m4(function(boost::move(m3)));
 113       ::boost::ignore_unused(m);::boost::ignore_unused(m2);::boost::ignore_unused(m3);::boost::ignore_unused(m4);
 114    }
 115    {
 116       movable m;
 117       movable m2(boost::move(m));
 118       movable m3(functionr(movable(boost::move(m2))));
 119       movable m4(functionr(boost::move(m3)));
 120       ::boost::ignore_unused(m);::boost::ignore_unused(m2);::boost::ignore_unused(m3);::boost::ignore_unused(m4);
 121    }
 122    {
 123       movable m;
 124       movable m2(boost::move(m));
 125       movable m3(function2(movable(boost::move(m2))));
 126       movable m4(function2(boost::move(m3)));
 127       ::boost::ignore_unused(m);::boost::ignore_unused(m2);::boost::ignore_unused(m3);::boost::ignore_unused(m4);
 128    }
 129    {
 130       movable m;
 131       movable m2(boost::move(m));
 132       movable m3(function2r(movable(boost::move(m2))));
 133       movable m4(function2r(boost::move(m3)));
 134       ::boost::ignore_unused(m);::boost::ignore_unused(m2);::boost::ignore_unused(m3);::boost::ignore_unused(m4);
 135    }
 136    {
 137       movable m;
 138       movable m2(boost::move(m));
 139       movable m3(move_return_function());
 140       ::boost::ignore_unused(m);::boost::ignore_unused(m2);::boost::ignore_unused(m3);
 141    }
 142    {
 143       movable m;
 144       movable m2(boost::move(m));
 145       movable m3(move_return_function2());
 146       ::boost::ignore_unused(m);::boost::ignore_unused(m2);::boost::ignore_unused(m3);
 147    }
 148    {
 149       //movable
 150       movable m (factory_wrapper<movable>(factory<movable>()));
 151       m = factory_wrapper<movable>(factory<movable>());
 152       movable&mr(factory_wrapper<movable&>(factory<movable&>()));
 153       movable&mr2 = factory_wrapper<movable&>(factory<movable&>());
 154       ::boost::ignore_unused(mr);
 155       ::boost::ignore_unused(mr2);
 156       ::boost::ignore_unused(m);
 157    }
 158    {
 159       //copyable
 160       copyable c (factory_wrapper<copyable>(factory<copyable>()));
 161       c = factory_wrapper<copyable>(factory<copyable>());
 162       copyable&cr(factory_wrapper<copyable&>(factory<copyable&>()));
 163       copyable&cr2 = factory_wrapper<copyable&>(factory<copyable&>());
 164       ::boost::ignore_unused(cr);
 165       ::boost::ignore_unused(cr2);
 166       ::boost::ignore_unused(c);
 167    }
 168
 169    {
 170       //copy_movable
 171       copy_movable c (factory_wrapper<copy_movable>(factory<copy_movable>()));
 172       c = factory_wrapper<copy_movable>(factory<copy_movable>());
 173       copy_movable&cr(factory_wrapper<copy_movable&>(factory<copy_movable&>()));
 174       copy_movable&cr2 = factory_wrapper<copy_movable&>(factory<copy_movable&>());
 175       ::boost::ignore_unused(cr);
 176       ::boost::ignore_unused(cr2);
 177       ::boost::ignore_unused(c);
 178    }
 179
 180    return 0;
 181 }