[Boost-commit] svn:boost r82112 - in sandbox/static_vector: boost/container/detail test

Subject: [Boost-commit] svn:boost r82112 - in sandbox/static_vector: boost/container/detail test
From: athundt_at_[hidden]
Date: 2012-12-20 03:25:39

Author: ahundt
Date: 2012-12-20 03:25:38 EST (Thu, 20 Dec 2012)
New Revision: 82112
URL: http://svn.boost.org/trac/boost/changeset/82112

Log:
added boost::move to detail helpers and added unit tests for classes with move support
Text files modified: 
   sandbox/static_vector/boost/container/detail/static_vector_util.hpp |     7 +-                                      
   sandbox/static_vector/test/static_vector.cpp                        |    96 ++++++++++++++++++++++++++++++++++++--- 
   2 files changed, 92 insertions(+), 11 deletions(-)

Modified: sandbox/static_vector/boost/container/detail/static_vector_util.hpp
==============================================================================
--- sandbox/static_vector/boost/container/detail/static_vector_util.hpp	(original)
+++ sandbox/static_vector/boost/container/detail/static_vector_util.hpp	2012-12-20 03:25:38 EST (Thu, 20 Dec 2012)
@@ -32,6 +32,7 @@
 //#include <boost/type_traits/has_nothrow_assign.hpp>
 //#include <boost/type_traits/has_nothrow_destructor.hpp>
 
+#include <boost/move/move.hpp>
 #include <boost/utility/addressof.hpp>
 #include <boost/iterator/iterator_traits.hpp>
 
@@ -178,7 +179,7 @@
 F uninitialized_copy_dispatch(I first, I last, F dst,
                                  boost::mpl::bool_<false> const& /*use_memcpy*/)
 {
-    return std::uninitialized_copy(first, last, dst);                           // may throw
+    return boost::uninitialized_copy_or_move(first, last, dst);                           // may throw
 }
 
 template <typename I, typename F>
@@ -243,7 +244,7 @@
 O move_dispatch(I first, I last, O dst,
                 boost::mpl::bool_<false> const& /*use_memmove*/)
 {
-    return std::copy(first, last, dst);                                         // may throw
+    return boost::move(first, last, dst);                                         // may throw
 }
 
 template <typename I, typename O>
@@ -281,7 +282,7 @@
 BDO move_backward_dispatch(BDI first, BDI last, BDO dst,
                            boost::mpl::bool_<false> const& /*use_memmove*/)
 {
-    return std::copy_backward(first, last, dst);                                // may throw
+    return boost::move_backward(first, last, dst);                                // may throw
 }
 
 template <typename BDI, typename BDO>

Modified: sandbox/static_vector/test/static_vector.cpp
==============================================================================
--- sandbox/static_vector/test/static_vector.cpp	(original)
+++ sandbox/static_vector/test/static_vector.cpp	2012-12-20 03:25:38 EST (Thu, 20 Dec 2012)
@@ -19,6 +19,7 @@
 #include <vector>
 #include <list>
 #include <boost/shared_ptr.hpp>
+#include "movable.hpp"
 
 using namespace boost::container;
 
@@ -61,11 +62,34 @@
 public:
     explicit counting_value(int a = 0) : aa(a) { ++c(); }
     counting_value(counting_value const& v) : aa(v.aa) { ++c(); }
-    counting_value & operator=(counting_value const& v) { aa = v.aa; return *this; }
+    //counting_value & operator=(counting_value const& v) { aa = v.aa; return *this; }
     ~counting_value() { --c(); }
     bool operator==(counting_value const& v) const { return aa == v.aa; }
     static size_t count() { return c(); }
     static void init() { c() = 0; }
+    
+
+   counting_value& operator=(BOOST_COPY_ASSIGN_REF(counting_value) p) // Copy assignment
+   {
+      if (this != &p){
+         int tmp_aa = p.aa ? p.aa : 0;
+         aa = tmp_aa;
+      }
+      return *this;
+   }
+
+   //Move semantics...
+   counting_value(BOOST_RV_REF(counting_value) p)            //Move constructor
+      : aa(p.aa) { p.aa = 0; }
+
+   counting_value& operator=(BOOST_RV_REF(counting_value) p) //Move assignment
+   {
+      if (this != &p){
+         aa = p.aa;
+         p.aa = 0;
+      }
+      return *this;
+   }
 private:
     static size_t & c() { static size_t co = 0; return co; }
     int aa;
@@ -81,6 +105,53 @@
     boost::shared_ptr<int> m_ptr;
 };
 
+template <class T>
+class clone_ptr
+{
+   private:
+   // Mark this class copyable and movable
+   BOOST_COPYABLE_AND_MOVABLE(clone_ptr)
+   T* ptr;
+
+   public:
+   // Construction
+   explicit clone_ptr(T* p = 0) : ptr(p) {}
+
+   // Destruction
+   ~clone_ptr() { delete ptr; }
+
+   clone_ptr(const clone_ptr& p) // Copy constructor (as usual)
+      : ptr(p.ptr ? p.ptr->clone() : 0) {}
+
+   clone_ptr& operator=(BOOST_COPY_ASSIGN_REF(clone_ptr) p) // Copy assignment
+   {
+      if (this != &p){
+         T *tmp_p = p.ptr ? p.ptr->clone() : 0;
+         delete ptr;
+         ptr = tmp_p;
+      }
+      return *this;
+   }
+
+   //Move semantics...
+   clone_ptr(BOOST_RV_REF(clone_ptr) p)            //Move constructor
+      : ptr(p.ptr) { p.ptr = 0; }
+
+   clone_ptr& operator=(BOOST_RV_REF(clone_ptr) p) //Move assignment
+   {
+      if (this != &p){
+         delete ptr;
+         ptr = p.ptr;
+         p.ptr = 0;
+      }
+      return *this;
+   }
+   
+   bool operator==(const clone_ptr&){
+     
+   }
+};
+
 template <typename T, size_t N>
 void test_ctor_ndc()
 {
@@ -568,96 +639,105 @@
 int test_main(int, char* [])
 #endif // BOOST_SINGLE_HEADER_UTF
 {
-  BOOST_CHECK(true);
-  counting_value::init();
-  int zero = 0;
-  //BOOST_CHECK_EQUAL(0, 0);
-  zero = counting_value::count();
   
-  //BOOST_CHECK_EQUAL(counting_value::count(), 0);
+    BOOST_CHECK_EQUAL(counting_value::count(), 0);
     test_ctor_ndc<int, 10>();
     test_ctor_ndc<value_ndc, 10>();
     test_ctor_ndc<counting_value, 10>();
-    //BOOST_CHECK(counting_value::count() == 0);
+    BOOST_CHECK(counting_value::count() == 0);
     test_ctor_ndc<shptr_value, 10>();
+    test_ctor_ndc<copy_movable, 10>();
 
     test_ctor_nc<int, 10>(5);
     test_ctor_nc<value_nc, 10>(5);
     test_ctor_nc<counting_value, 10>(5);
     BOOST_CHECK(counting_value::count() == 0);
     test_ctor_nc<shptr_value, 10>(5);
+    test_ctor_nc<copy_movable, 10>(5);
 
     test_ctor_nd<int, 10>(5, 1);
     test_ctor_nd<value_nd, 10>(5, value_nd(1));
     test_ctor_nd<counting_value, 10>(5, counting_value(1));
     BOOST_CHECK(counting_value::count() == 0);
     test_ctor_nd<shptr_value, 10>(5, shptr_value(1));
+    test_ctor_nd<copy_movable, 10>(5, produce());
 
     test_resize_nc<int, 10>(5);
     test_resize_nc<value_nc, 10>(5);
     test_resize_nc<counting_value, 10>(5);
     BOOST_CHECK(counting_value::count() == 0);
     test_resize_nc<shptr_value, 10>(5);
+    test_resize_nc<copy_movable, 10>(5);
 
     test_resize_nd<int, 10>(5, 1);
     test_resize_nd<value_nd, 10>(5, value_nd(1));
     test_resize_nd<counting_value, 10>(5, counting_value(1));
     BOOST_CHECK(counting_value::count() == 0);
     test_resize_nd<shptr_value, 10>(5, shptr_value(1));
+    test_resize_nd<copy_movable, 10>(5, produce());
 
     test_push_back_nd<int, 10>();
     test_push_back_nd<value_nd, 10>();
     test_push_back_nd<counting_value, 10>();
     BOOST_CHECK(counting_value::count() == 0);
     test_push_back_nd<shptr_value, 10>();
+    test_push_back_nd<copy_movable, 10>();
 
     test_pop_back_nd<int, 10>();
     test_pop_back_nd<value_nd, 10>();
     test_pop_back_nd<counting_value, 10>();
     BOOST_CHECK(counting_value::count() == 0);
     test_pop_back_nd<shptr_value, 10>();
+    test_pop_back_nd<copy_movable, 10>();
 
     test_copy_and_assign_nd<int, 10>(1);
     test_copy_and_assign_nd<value_nd, 10>(value_nd(1));
     test_copy_and_assign_nd<counting_value, 10>(counting_value(1));
     BOOST_CHECK(counting_value::count() == 0);
     test_copy_and_assign_nd<shptr_value, 10>(shptr_value(1));
+    test_copy_and_assign_nd<copy_movable, 10>(produce());
 
     test_iterators_nd<int, 10>();
     test_iterators_nd<value_nd, 10>();
     test_iterators_nd<counting_value, 10>();
     BOOST_CHECK(counting_value::count() == 0);
     test_iterators_nd<shptr_value, 10>();
+    test_iterators_nd<copy_movable, 10>();
 
     test_erase_nd<int, 10>();
     test_erase_nd<value_nd, 10>();
     test_erase_nd<counting_value, 10>();
     BOOST_CHECK(counting_value::count() == 0);
     test_erase_nd<shptr_value, 10>();
+    test_erase_nd<copy_movable, 10>();
 
     test_insert_nd<int, 10>(50);
     test_insert_nd<value_nd, 10>(value_nd(50));
     test_insert_nd<counting_value, 10>(counting_value(50));
     BOOST_CHECK(counting_value::count() == 0);
     test_insert_nd<shptr_value, 10>(shptr_value(50));
+    test_insert_nd<copy_movable, 10>(produce());
 
     test_capacity_0_nd<int>();
     test_capacity_0_nd<value_nd>();
     test_capacity_0_nd<counting_value>();
     BOOST_CHECK(counting_value::count() == 0);
     test_capacity_0_nd<shptr_value>();
+    test_capacity_0_nd<copy_movable>();
 
     test_exceptions_nd<int, 10>();
     test_exceptions_nd<value_nd, 10>();
     test_exceptions_nd<counting_value, 10>();
     BOOST_CHECK(counting_value::count() == 0);
     test_exceptions_nd<shptr_value, 10>();
+    test_exceptions_nd<copy_movable, 10>();
 
     test_swap_nd<int, 10>();
     test_swap_nd<value_nd, 10>();
     test_swap_nd<counting_value, 10>();
     BOOST_CHECK(counting_value::count() == 0);
     test_swap_nd<shptr_value, 10>();
+    test_swap_nd<copy_movable, 10>();
 
 #ifndef BOOST_SINGLE_HEADER_UTF
     return 0;