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

Subject: [Boost-commit] svn:boost r82322 - in sandbox/static_vector: boost/container test
From: adam.wulkiewicz_at_[hidden]
Date: 2013-01-02 14:12:35

Author: awulkiew
Date: 2013-01-02 14:12:34 EST (Wed, 02 Jan 2013)
New Revision: 82322
URL: http://svn.boost.org/trac/boost/changeset/82322

Log:
Used NullAllocator-like Strategy.
Fixed some errors.
Value*, const Value*, etc. replaced by pointer, const_pointer, etc.
Text files modified: 
   sandbox/static_vector/boost/container/static_vector.hpp        |   167 ++++++++++++++++++++++----------------- 
   sandbox/static_vector/test/Jamfile.v2                          |     4                                         
   sandbox/static_vector/test/static_vector_interprocess_test.cpp |     2                                         
   sandbox/static_vector/test/static_vector_test.cpp              |    60 ++++++++-----                           
   sandbox/static_vector/test/static_vector_test.hpp              |    15 ---                                     
   5 files changed, 132 insertions(+), 116 deletions(-)

Modified: sandbox/static_vector/boost/container/static_vector.hpp
==============================================================================
--- sandbox/static_vector/boost/container/static_vector.hpp	(original)
+++ sandbox/static_vector/boost/container/static_vector.hpp	2013-01-02 14:12:34 EST (Wed, 02 Jan 2013)
@@ -36,25 +36,40 @@
 // or boost/detail/iterator.hpp ?
 #include <boost/iterator/reverse_iterator.hpp>
 
+// TODO - change the name Strategy to NullAllocator?
+
 namespace boost { namespace container {
 
 // Forward declaration
-template <typename Value, std::size_t Capacity, typename Strategy>
+template <typename Value, std::size_t Capacity, typename Strategy/*NullAllocator*/>
 class static_vector;
 
 namespace static_vector_detail {
 
-// TODO - should strategy define only an error handler instead of a check?
-// e.g. check_capacity_failed(...) { assert(false); }
-// this means that the checking condition would allways be checked
-// safer since the user couldn't play with the check, but a penalty in some cases
+template <typename Value>
+struct default_strategy/*null_allocator*/
+{
+    typedef Value value_type;
+    typedef std::size_t size_type;
+    typedef std::ptrdiff_t difference_type;
+    typedef Value* pointer;
+    typedef const Value* const_pointer;
+    typedef Value& reference;
+    typedef const Value& const_reference;
 
-struct default_strategy
+    static void allocate_failed()
+    {
+        BOOST_ASSERT_MSG(false, "size can't exceed the capacity");
+    }
+};
+
+struct default_error_handler
 {
     template <typename V, std::size_t Capacity, typename S>
     static void check_capacity(container::static_vector<V, Capacity, S> const&, std::size_t s)
     {
-        BOOST_ASSERT_MSG(s <= Capacity, "size can't exceed the capacity");
+        if ( Capacity < s )
+            S::allocate_failed();
     }
 
     template <typename V, std::size_t C, typename S>
@@ -98,24 +113,34 @@
     }
 };
 
-template <typename Value, std::size_t Capacity, typename Strategy>
+template <typename Value, std::size_t Capacity, typename Strategy/*NullAllocator*/>
 struct static_vector_traits
 {
-    typedef std::size_t size_type;
+    typedef typename Strategy::value_type value_type;
+    typedef typename Strategy::size_type size_type;
+    typedef typename Strategy::difference_type difference_type;
+    typedef typename Strategy::pointer pointer;
+    typedef typename Strategy::const_pointer const_pointer;
+    typedef typename Strategy::reference reference;
+    typedef typename Strategy::const_reference const_reference;
+
+    typedef default_error_handler error_handler;
+
     typedef boost::false_type use_memop_in_swap_and_move;
     typedef boost::false_type use_optimized_swap;
-    typedef Strategy strategy;
 };
 
 } // namespace static_vector_detail
 
-template <typename Value, std::size_t Capacity, typename Strategy = static_vector_detail::default_strategy >
+template <typename Value, std::size_t Capacity, typename Strategy/*NullAllocator*/ = static_vector_detail::default_strategy<Value>/*null_allocator*/ >
 class static_vector
 {
-    typedef typename
-    static_vector_detail::static_vector_traits<
+    typedef static_vector_detail::static_vector_traits<
         Value, Capacity, Strategy
-    >::size_type stored_size_type;
+    > vt;
+    
+    typedef typename vt::size_type stored_size_type;
+    typedef typename vt::error_handler errh;
 
     BOOST_MPL_ASSERT_MSG(
         ( boost::is_unsigned<stored_size_type>::value &&
@@ -129,11 +154,6 @@
         boost::alignment_of<Value[Capacity]>::value
     > aligned_storage_type;
 
-    typedef typename
-    static_vector_detail::static_vector_traits<
-        Value, Capacity, Strategy
-    >::strategy errh;
-
     template <typename V, std::size_t C, typename S>
     friend class static_vector;
 
@@ -151,15 +171,16 @@
 #endif
 
 public:
-    typedef Value value_type;
+    typedef typename vt::value_type value_type;
     typedef stored_size_type size_type;
-    typedef std::ptrdiff_t difference_type;
-    typedef Value & reference;
-    typedef Value const& const_reference;
-    typedef Value* pointer;
-    typedef const Value* const_pointer;
-    typedef Value* iterator;
-    typedef const Value* const_iterator;
+    typedef typename vt::difference_type difference_type;
+    typedef typename vt::pointer pointer;
+    typedef typename vt::const_pointer const_pointer;
+    typedef typename vt::reference reference;
+    typedef typename vt::const_reference const_reference;
+
+    typedef pointer iterator;
+    typedef const_pointer const_iterator;
     typedef boost::reverse_iterator<iterator> reverse_iterator;
     typedef boost::reverse_iterator<const_iterator> const_reverse_iterator;
 
@@ -707,7 +728,7 @@
 
     //! Throws: If the Strategy throws in check_at().
     //! Complexity: Constant.
-    Value & at(size_type i)
+    reference at(size_type i)
     {
         errh::check_at(*this, i);                                   // may throw
         return *(this->begin() + i);
@@ -715,7 +736,7 @@
 
     //! Throws: If the Strategy throws in check_at().
     //! Complexity: Constant.
-    Value const& at(size_type i) const
+    const_reference at(size_type i) const
     {
         errh::check_at(*this, i);                                   // may throw
         return *(this->begin() + i);
@@ -723,7 +744,7 @@
 
     //! Throws: If the Strategy throws in check_operator_brackets().
     //! Complexity: Constant.
-    Value & operator[](size_type i)
+    reference operator[](size_type i)
     {
         errh::check_operator_brackets(*this, i);
         return *(this->begin() + i);
@@ -731,7 +752,7 @@
 
     //! Throws: If the Strategy throws in check_operator_brackets().
     //! Complexity: Constant.
-    Value const& operator[](size_type i) const
+    const_reference operator[](size_type i) const
     {
         errh::check_operator_brackets(*this, i);
         return *(this->begin() + i);
@@ -739,7 +760,7 @@
 
     //! Throws: If the Strategy throws in check_empty().
     //! Complexity: Constant.
-    Value & front()
+    reference front()
     {
         errh::check_empty(*this);
         return *(this->begin());
@@ -747,7 +768,7 @@
 
     //! Throws: If the Strategy throws in check_empty().
     //! Complexity: Constant.
-    Value const& front() const
+    const_reference front() const
     {
         errh::check_empty(*this);
         return *(this->begin());
@@ -755,7 +776,7 @@
 
     //! Throws: If the Strategy throws in check_empty().
     //! Complexity: Constant.
-    Value & back()
+    reference back()
     {
         errh::check_empty(*this);
         return *(this->end() - 1);
@@ -763,7 +784,7 @@
 
     //! Throws: If the Strategy throws in check_empty().
     //! Complexity: Constant.
-    Value const& back() const
+    const_reference back() const
     {
         errh::check_empty(*this);
         return *(this->end() - 1);
@@ -771,10 +792,10 @@
 
     //! Throws: Nothing.
     //! Complexity: Constant.
-    Value * data() { return this->ptr(); }
+    pointer data() { return boost::addressof(*(this->ptr())); }
     //! Throws: Nothing.
     //! Complexity: Constant.
-    const Value * data() const { return this->ptr(); }
+    const_pointer data() const { return boost::addressof(*(this->ptr())); }
 
     //! Throws: Nothing.
     //! Complexity: Constant.
@@ -1132,14 +1153,14 @@
         m_size = s; // update end
     }
 
-    Value * ptr()
+    pointer ptr()
     {
-        return (reinterpret_cast<Value*>(m_storage.address()));
+        return pointer(static_cast<Value*>(m_storage.address()));
     }
 
-    const Value * ptr() const
+    const_pointer ptr() const
     {
-        return (reinterpret_cast<const Value*>(m_storage.address()));
+        return const_pointer(static_cast<const Value*>(m_storage.address()));
     }
 
     stored_size_type m_size;
@@ -1151,26 +1172,24 @@
 template<typename Value, typename Strategy>
 class static_vector<Value, 0, Strategy>
 {
-    typedef typename
-    static_vector_detail::static_vector_traits<
+    typedef static_vector_detail::static_vector_traits<
         Value, 0, Strategy
-    >::size_type stored_size_type;
+    > vt;
 
-    typedef typename
-    static_vector_detail::static_vector_traits<
-        Value, 0, Strategy
-    >::strategy errh;
+    typedef typename vt::size_type stored_size_type;
+    typedef typename vt::error_handler errh;
 
 public:
-    typedef Value value_type;
+    typedef typename vt::value_type value_type;
     typedef stored_size_type size_type;
-    typedef std::ptrdiff_t difference_type;
-    typedef Value& reference;
-    typedef Value const& const_reference;
-    typedef Value * pointer;
-    typedef const Value* const_pointer;
-    typedef Value* iterator;
-    typedef const Value * const_iterator;
+    typedef typename vt::difference_type difference_type;
+    typedef typename vt::pointer pointer;
+    typedef typename vt::const_pointer const_pointer;
+    typedef typename vt::reference reference;
+    typedef typename vt::const_reference const_reference;
+
+    typedef pointer iterator;
+    typedef const_pointer const_iterator;
     typedef boost::reverse_iterator<iterator> reverse_iterator;
     typedef boost::reverse_iterator<const_iterator> const_reverse_iterator;
 
@@ -1196,8 +1215,8 @@
     }
 
     // strong
-    template <size_t C>
-    static_vector(static_vector<value_type, C> const& other)
+    template <size_t C, typename S>
+    static_vector(static_vector<value_type, C, S> const& other)
     {
         errh::check_capacity(*this, other.size());                                  // may throw
     }
@@ -1217,8 +1236,8 @@
     }
 
     // basic
-    template <size_t C>
-    static_vector & operator=(static_vector<value_type, C> const& other)
+    template <size_t C, typename S>
+    static_vector & operator=(static_vector<value_type, C, S> const& other)
     {
         errh::check_capacity(*this, other.size());                                  // may throw
         return *this;
@@ -1314,64 +1333,64 @@
     void clear() {}
 
     // strong
-    Value & at(size_type i)
+    reference at(size_type i)
     {
         errh::check_at(*this, i);                                   // may throw
         return *(this->begin() + i);
     }
 
     // strong
-    Value const& at(size_type i) const
+    const_reference at(size_type i) const
     {
         errh::check_at(*this, i);                                   // may throw
         return *(this->begin() + i);
     }
 
     // nothrow
-    Value & operator[](size_type i)
+    reference operator[](size_type i)
     {
         errh::check_operator_brackets(*this, i);
         return *(this->begin() + i);
     }
 
     // nothrow
-    Value const& operator[](size_type i) const
+    const_reference operator[](size_type i) const
     {
         errh::check_operator_brackets(*this, i);
         return *(this->begin() + i);
     }
 
     // nothrow
-    Value & front()
+    reference front()
     {
         errh::check_empty(*this);
         return *(this->begin());
     }
 
     // nothrow
-    Value const& front() const
+    const_reference front() const
     {
         errh::check_empty(*this);
         return *(this->begin());
     }
 
     // nothrow
-    Value & back()
+    reference back()
     {
         errh::check_empty(*this);
         return *(this->end() - 1);
     }
 
     // nothrow
-    Value const& back() const
+    const_reference back() const
     {
         errh::check_empty(*this);
         return *(this->end() - 1);
     }
 
     // nothrow
-    Value * data() { return this->ptr(); }
-    const Value * data() const { return this->ptr(); }
+    pointer data() { return boost::addressof(*(this->ptr())); }
+    const_pointer data() const { return boost::addressof(*(this->ptr())); }
 
     // nothrow
     iterator begin() { return this->ptr(); }
@@ -1396,14 +1415,14 @@
 
 private:
 
-    Value * ptr()
+    pointer ptr()
     {
-        return (reinterpret_cast<Value*>(this));
+        return pointer(reinterpret_cast<Value*>(this));
     }
 
-    const Value * ptr() const
+    const_pointer ptr() const
     {
-        return (reinterpret_cast<const Value*>(this));
+        return const_pointer(reinterpret_cast<const Value*>(this));
     }
 };
 

Modified: sandbox/static_vector/test/Jamfile.v2
==============================================================================
--- sandbox/static_vector/test/Jamfile.v2	(original)
+++ sandbox/static_vector/test/Jamfile.v2	2013-01-02 14:12:34 EST (Wed, 02 Jan 2013)
@@ -18,11 +18,11 @@
     ;
 
 test-suite boost-container-static_vector
-    : [ run static_vector.cpp ]
+    : [ run static_vector_test.cpp ]
     ;
 
 test-suite boost-container-static_vector_interprocess
-    : [ run static_vector_interprocess.cpp /boost/thread//boost_thread
+    : [ run static_vector_interprocess_test.cpp /boost/thread//boost_thread
         :  # additional args
         :  # test-files
         :  # requirements

Modified: sandbox/static_vector/test/static_vector_interprocess_test.cpp
==============================================================================
--- sandbox/static_vector/test/static_vector_interprocess_test.cpp	(original)
+++ sandbox/static_vector/test/static_vector_interprocess_test.cpp	2013-01-02 14:12:34 EST (Wed, 02 Jan 2013)
@@ -16,7 +16,7 @@
 #include <boost/test/impl/execution_monitor.ipp>
 #endif // BOOST_SINGLE_HEADER_UTF
 
-#include "static_vector.hpp"
+#include "static_vector_test.hpp"
 
 #include <boost/interprocess/managed_shared_memory.hpp>
 #include <algorithm>

Modified: sandbox/static_vector/test/static_vector_test.cpp
==============================================================================
--- sandbox/static_vector/test/static_vector_test.cpp	(original)
+++ sandbox/static_vector/test/static_vector_test.cpp	2013-01-02 14:12:34 EST (Wed, 02 Jan 2013)
@@ -16,7 +16,23 @@
 #include <boost/test/impl/execution_monitor.ipp>
 #endif // BOOST_SINGLE_HEADER_UTF
 
-#include "static_vector.hpp"
+// TODO: Disable parts of the unit test that should not run when BOOST_NO_EXCEPTIONS
+// if exceptions are enabled there must be a user defined throw_exception function
+#ifdef BOOST_NO_EXCEPTIONS
+namespace boost {
+    void throw_exception(std::exception const & e){}; // user defined
+} // namespace boost
+#endif // BOOST_NO_EXCEPTIONS
+
+#include <vector>
+#include <list>
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#include <boost/container/vector.hpp>
+#include <boost/container/stable_vector.hpp>
+#endif
+
+#include "static_vector_test.hpp"
 
 template <typename T, size_t N>
 void test_ctor_ndc()
@@ -403,17 +419,13 @@
 #endif
 }
 
-struct bad_alloc_strategy : public static_vector_detail::default_strategy
+template <typename V>
+struct bad_alloc_strategy
+    : public static_vector_detail::default_strategy<V>
 {
-    template <typename V, std::size_t Capacity, typename S>
-    static void check_capacity(static_vector<V, Capacity, S> const&, std::size_t s)
+    static void allocate_failed()
     {
-#ifndef BOOST_NO_EXCEPTIONS
-        if ( Capacity < s )
-            throw std::bad_alloc();
-#else // BOOST_NO_EXCEPTIONS
-        BOOST_ASSERT_MSG(!(Capacity < s), "index out of bounds");
-#endif // BOOST_NO_EXCEPTIONS
+        BOOST_THROW_EXCEPTION(std::bad_alloc());
     }
 };
 
@@ -422,7 +434,7 @@
 {
     static_vector<T, 10> v(5u, T(0));
 
-    static_vector<T, 0, bad_alloc_strategy> s;
+    static_vector<T, 0, bad_alloc_strategy<T> > s;
     BOOST_CHECK(s.size() == 0);
     BOOST_CHECK(s.capacity() == 0);
 #ifndef BOOST_NO_EXCEPTIONS
@@ -435,11 +447,11 @@
     BOOST_CHECK_THROW(s.assign(v.begin(), v.end()), std::bad_alloc);
     BOOST_CHECK_THROW(s.assign(5u, T(0)), std::bad_alloc);
     try{
-        static_vector<T, 0, bad_alloc_strategy> s2(v.begin(), v.end());
+        static_vector<T, 0, bad_alloc_strategy<T> > s2(v.begin(), v.end());
         BOOST_CHECK(false);
     }catch(std::bad_alloc &){}
     try{
-        static_vector<T, 0, bad_alloc_strategy> s1(5u, T(0));
+        static_vector<T, 0, bad_alloc_strategy<T> > s1(5u, T(0));
         BOOST_CHECK(false);
     }catch(std::bad_alloc &){}
 #endif // BOOST_NO_EXCEPTIONS
@@ -449,7 +461,7 @@
 void test_exceptions_nd()
 {
     static_vector<T, N> v(N, T(0));
-    static_vector<T, N/2, bad_alloc_strategy> s(N/2, T(0));
+    static_vector<T, N/2, bad_alloc_strategy<T> > s(N/2, T(0));
 
 #ifndef BOOST_NO_EXCEPTIONS
     BOOST_CHECK_THROW(s.resize(N, T(0)), std::bad_alloc);
@@ -460,11 +472,11 @@
     BOOST_CHECK_THROW(s.assign(v.begin(), v.end()), std::bad_alloc);
     BOOST_CHECK_THROW(s.assign(N, T(0)), std::bad_alloc);
     try{
-        static_vector<T, N/2, bad_alloc_strategy> s2(v.begin(), v.end());
+        static_vector<T, N/2, bad_alloc_strategy<T> > s2(v.begin(), v.end());
         BOOST_CHECK(false);
     }catch(std::bad_alloc &){}
     try{
-        static_vector<T, N/2, bad_alloc_strategy> s1(N, T(0));
+        static_vector<T, N/2, bad_alloc_strategy<T> > s1(N, T(0));
         BOOST_CHECK(false);
     }catch(std::bad_alloc &){}
 #endif // BOOST_NO_EXCEPTIONS
@@ -476,7 +488,7 @@
     {
         static_vector<T, N> v1, v2, v3, v4;
         static_vector<T, N> s1, s2;
-        static_vector<T, N, bad_alloc_strategy> s4;
+        static_vector<T, N, bad_alloc_strategy<T> > s4;
 
         for (size_t i = 0 ; i < N ; ++i )
         {
@@ -555,14 +567,14 @@
     }
     {
         static_vector<T, N> v(N, T(0));
-        static_vector<T, N/2, bad_alloc_strategy> s(N/2, T(1));
+        static_vector<T, N/2, bad_alloc_strategy<T> > s(N/2, T(1));
 #ifndef BOOST_NO_EXCEPTIONS
         BOOST_CHECK_THROW(s.swap(v), std::bad_alloc);
         v.resize(N, T(0));
         BOOST_CHECK_THROW(s = boost::move(v), std::bad_alloc);
         v.resize(N, T(0));
         try {
-            static_vector<T, N/2, bad_alloc_strategy> s2(boost::move(v));
+            static_vector<T, N/2, bad_alloc_strategy<T> > s2(boost::move(v));
             BOOST_CHECK(false);
         } catch (std::bad_alloc &) {}
 #endif // BOOST_NO_EXCEPTIONS
@@ -574,7 +586,7 @@
 {
     //emplace_back(pos, int, int)
     {
-        static_vector<T, N, bad_alloc_strategy> v;
+        static_vector<T, N, bad_alloc_strategy<T> > v;
 
         for (int i = 0 ; i < int(N) ; ++i )
             v.emplace_back(i, 100 + i);
@@ -589,11 +601,11 @@
 
     // emplace(pos, int, int)
     {
-        typedef typename static_vector<T, N, bad_alloc_strategy>::iterator It;
+        typedef typename static_vector<T, N, bad_alloc_strategy<T> >::iterator It;
 
         int h = N / 2;
 
-        static_vector<T, N, bad_alloc_strategy> v;
+        static_vector<T, N, bad_alloc_strategy<T> > v;
         for ( int i = 0 ; i < h ; ++i )
             v.emplace_back(i, 100 + i);
 
@@ -615,9 +627,9 @@
 template <typename T, size_t N>
 void test_sv_elem(T const& t)
 {
-    typedef static_vector<T, N, bad_alloc_strategy> V;
+    typedef static_vector<T, N, bad_alloc_strategy<T> > V;
 
-    static_vector<V, N, bad_alloc_strategy> v;
+    static_vector<V, N, bad_alloc_strategy<V> > v;
 
     v.push_back(V(N/2, t));
     V vvv(N/2, t);

Modified: sandbox/static_vector/test/static_vector_test.hpp
==============================================================================
--- sandbox/static_vector/test/static_vector_test.hpp	(original)
+++ sandbox/static_vector/test/static_vector_test.hpp	2013-01-02 14:12:34 EST (Wed, 02 Jan 2013)
@@ -13,24 +13,9 @@
 
 #include <boost/container/static_vector.hpp>
 
-#include <vector>
-#include <list>
 #include <boost/shared_ptr.hpp>
 #include "movable.hpp"
 
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-#include <boost/container/vector.hpp>
-#include <boost/container/stable_vector.hpp>
-#endif
-
-// TODO: Disable parts of the unit test that should not run when BOOST_NO_EXCEPTIONS
-// if exceptions are enabled there must be a user defined throw_exception function
-#ifdef BOOST_NO_EXCEPTIONS
-namespace boost {
-void throw_exception(std::exception const & e){}; // user defined
-} // namespace boost
-#endif // BOOST_NO_EXCEPTIONS
-
 using namespace boost::container;
 
 class value_ndc